diff --git a/go.mod b/go.mod index 9bc6acf88..6bbebd4f5 100644 --- a/go.mod +++ b/go.mod @@ -12,7 +12,7 @@ require ( github.com/dgraph-io/ristretto/v2 v2.3.0 github.com/gin-gonic/gin v1.10.0 github.com/hashicorp/go-uuid v1.0.3 - github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251125091810-0f15d56ca782 + github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251126143438-6cc7726dadb6 github.com/hyperledger/fabric v1.4.0-rc1.0.20250510200036-435a7f1a780a github.com/hyperledger/fabric-chaincode-go/v2 v2.3.0 github.com/hyperledger/fabric-lib-go v1.1.3-0.20240523144151-25edd1eaf5f5 @@ -20,8 +20,8 @@ require ( github.com/hyperledger/fabric-x-committer v0.1.5 github.com/jackc/pgx/v5 v5.7.6 github.com/mitchellh/mapstructure v1.5.0 - github.com/onsi/ginkgo/v2 v2.23.4 - github.com/onsi/gomega v1.37.0 + github.com/onsi/ginkgo/v2 v2.25.1 + github.com/onsi/gomega v1.38.2 github.com/prometheus/client_golang v1.20.5 github.com/prometheus/common v0.60.0 github.com/sourcegraph/conc v0.3.0 @@ -58,6 +58,7 @@ require ( github.com/IBM/idemix/bccsp/schemes/aries v0.0.0-20250313153527-832db18b9478 // indirect github.com/IBM/idemix/bccsp/schemes/weak-bb v0.0.0-20250313153527-832db18b9478 // indirect github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible // indirect + github.com/Masterminds/semver/v3 v3.4.0 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect github.com/alecthomas/kingpin/v2 v2.4.0 // indirect github.com/alecthomas/units v0.0.0-20240626203959-61d1e3462e30 // indirect @@ -278,6 +279,7 @@ require ( go.uber.org/fx v1.23.0 // indirect go.uber.org/mock v0.5.0 // indirect go.uber.org/multierr v1.11.0 // indirect + go.yaml.in/yaml/v3 v3.0.4 // indirect golang.org/x/arch v0.11.0 // indirect golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect golang.org/x/mod v0.29.0 // indirect diff --git a/go.sum b/go.sum index d38e6c668..516fddfd6 100644 --- a/go.sum +++ b/go.sum @@ -655,6 +655,8 @@ github.com/IBM/mathlib v0.0.3-0.20250709075152-a138079496c3/go.mod h1:O230ebw6/2 github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk= github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible h1:1G1pk05UrOh0NlF1oeaaix1x8XzrfjIDK47TY0Zehcw= github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= +github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0= +github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= @@ -1057,8 +1059,8 @@ github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= github.com/hyperledger-labs/SmartBFT v0.0.0-20250503203013-eb005eef8866 h1:Mu/6NJsfl9g3wM15Ue7hqPq4LtgYDoABh8MO4u8aW4g= github.com/hyperledger-labs/SmartBFT v0.0.0-20250503203013-eb005eef8866/go.mod h1:9aNHNXsCVy/leGz2gpTC1eOL5QecxbSAGjqsLh4T1LM= -github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251125091810-0f15d56ca782 h1:KEfatZmzBXpZWphBHfWKsS5vv0HID98Y1+BFNAHDKfI= -github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251125091810-0f15d56ca782/go.mod h1:AhHXfnrZ8Mxql05y4JUWt8ia6fTKruNdrcYEV6iEEBA= +github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251126143438-6cc7726dadb6 h1:oDIjI7IyHcFONm7a2ETtaTGp11yc+gZjRzeMbNsNaJw= +github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251126143438-6cc7726dadb6/go.mod h1:Ri5zkzmnmUzOCwk1Hgj3imaiblVQS2bm5G90oyqIgLU= github.com/hyperledger/aries-bbs-go v0.0.0-20240528084656-761671ea73bc h1:3Ykk6MtyfnlzMOQry9zkxsoLWpCWZwDPqehO/BJwArM= github.com/hyperledger/aries-bbs-go v0.0.0-20240528084656-761671ea73bc/go.mod h1:Kofn6A6WWea1ZM8Rys5aBW9dszwJ7Ywa0kyyYL0TPYw= github.com/hyperledger/fabric v1.4.0-rc1.0.20250510200036-435a7f1a780a h1:l9dE3iuE+mKj7K8Tcx904cF8zJpaNQONh3GNZdXnnyc= @@ -1321,8 +1323,8 @@ github.com/onsi/ginkgo/v2 v2.9.0/go.mod h1:4xkjoL/tZv4SMWeww56BU5kAt19mVB47gTWxm github.com/onsi/ginkgo/v2 v2.9.1/go.mod h1:FEcmzVcCHl+4o9bQZVab+4dC9+j+91t2FHSzmGAPfuo= github.com/onsi/ginkgo/v2 v2.9.2/go.mod h1:WHcJJG2dIlcCqVfBAwUCrJxSPFb6v4azBwgxeMeDuts= github.com/onsi/ginkgo/v2 v2.9.4/go.mod h1:gCQYp2Q+kSoIj7ykSVb9nskRSsR6PUj4AiLywzIhbKM= -github.com/onsi/ginkgo/v2 v2.23.4 h1:ktYTpKJAVZnDT4VjxSbiBenUjmlL/5QkBEocaWXiQus= -github.com/onsi/ginkgo/v2 v2.23.4/go.mod h1:Bt66ApGPBFzHyR+JO10Zbt0Gsp4uWxu5mIOTusL46e8= +github.com/onsi/ginkgo/v2 v2.25.1 h1:Fwp6crTREKM+oA6Cz4MsO8RhKQzs2/gOIVOUscMAfZY= +github.com/onsi/ginkgo/v2 v2.25.1/go.mod h1:ppTWQ1dh9KM/F1XgpeRqelR+zHVwV81DGRSDnFxK7Sk= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= @@ -1337,8 +1339,8 @@ github.com/onsi/gomega v1.27.1/go.mod h1:aHX5xOykVYzWOV4WqQy0sy8BQptgukenXpCXfad github.com/onsi/gomega v1.27.3/go.mod h1:5vG284IBtfDAmDyrK+eGyZmUgUlmi+Wngqo557cZ6Gw= github.com/onsi/gomega v1.27.4/go.mod h1:riYq/GJKh8hhoM01HN6Vmuy93AarCXCBGpvFDK3q3fQ= github.com/onsi/gomega v1.27.6/go.mod h1:PIQNjfQwkP3aQAH7lf7j87O/5FiNr+ZR8+ipb+qQlhg= -github.com/onsi/gomega v1.37.0 h1:CdEG8g0S133B4OswTDC/5XPSzE1OeP29QOioj2PID2Y= -github.com/onsi/gomega v1.37.0/go.mod h1:8D9+Txp43QWKhM24yyOBEdpkzN8FvJyAwecBgsU4KU0= +github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A= +github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k= github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040= @@ -1659,6 +1661,8 @@ go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI= go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= +go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE= golang.org/x/arch v0.11.0 h1:KXV8WWKCXm6tRpLirl2szsO5j/oOODwZf4hATmGVNs4= golang.org/x/arch v0.11.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys= diff --git a/token/config.go b/token/config.go index 4445bd7ad..49e7722f2 100644 --- a/token/config.go +++ b/token/config.go @@ -15,6 +15,11 @@ type Configuration struct { cm driver.Configuration } +// NewConfiguration returns a new instance of Configuration +func NewConfiguration(cm driver.Configuration) *Configuration { + return &Configuration{cm: cm} +} + // IsSet checks to see if the key has been set in any of the data locations func (m *Configuration) IsSet(key string) bool { return m.cm.IsSet(key) diff --git a/token/services/identity/storage/kvs/hashicorp/go.mod b/token/services/identity/storage/kvs/hashicorp/go.mod index 2d1055449..09db4b2be 100644 --- a/token/services/identity/storage/kvs/hashicorp/go.mod +++ b/token/services/identity/storage/kvs/hashicorp/go.mod @@ -8,7 +8,7 @@ require ( github.com/docker/docker v28.3.3+incompatible github.com/docker/go-connections v0.6.0 github.com/hashicorp/vault/api v1.16.0 - github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251125091810-0f15d56ca782 + github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251126143438-6cc7726dadb6 github.com/hyperledger-labs/fabric-token-sdk v0.4.1-0.20250528165839-032fb9265504 github.com/stretchr/testify v1.10.0 ) @@ -80,7 +80,7 @@ require ( github.com/morikuni/aec v1.0.0 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/ncruces/go-strftime v0.1.9 // indirect - github.com/onsi/gomega v1.37.0 // indirect + github.com/onsi/gomega v1.38.2 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect github.com/opencontainers/image-spec v1.1.1 // indirect github.com/pkg/errors v0.9.1 // indirect @@ -112,6 +112,7 @@ require ( go.opentelemetry.io/proto/otlp v1.5.0 // indirect go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.27.0 // indirect + go.yaml.in/yaml/v3 v3.0.4 // indirect golang.org/x/crypto v0.45.0 // indirect golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect golang.org/x/net v0.47.0 // indirect diff --git a/token/services/identity/storage/kvs/hashicorp/go.sum b/token/services/identity/storage/kvs/hashicorp/go.sum index 22cf12b0d..e4fa0fc66 100644 --- a/token/services/identity/storage/kvs/hashicorp/go.sum +++ b/token/services/identity/storage/kvs/hashicorp/go.sum @@ -13,6 +13,8 @@ github.com/IBM/idemix/bccsp/types v0.0.0-20250313153527-832db18b9478 h1:Uzmcb4pN github.com/IBM/idemix/bccsp/types v0.0.0-20250313153527-832db18b9478/go.mod h1:Pi1QIuIZ+1OXIbnYe27vNwJOnSq2WvkHRT/sfweTw8E= github.com/IBM/mathlib v0.0.3-0.20250709075152-a138079496c3 h1:TelnQIceKrhWVmuFnMXyKyq0WUG5zMT6u+7wnRMkcFY= github.com/IBM/mathlib v0.0.3-0.20250709075152-a138079496c3/go.mod h1:O230ebw6/22B7T4C03b99ZcPtc5XAfBTOp+ZT+xmMCk= +github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0= +github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE= @@ -127,8 +129,8 @@ github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hashicorp/vault/api v1.16.0 h1:nbEYGJiAPGzT9U4oWgaaB0g+Rj8E59QuHKyA5LhwQN4= github.com/hashicorp/vault/api v1.16.0/go.mod h1:KhuUhzOD8lDSk29AtzNjgAu2kxRA9jL9NAbkFlqvkBA= -github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251125091810-0f15d56ca782 h1:KEfatZmzBXpZWphBHfWKsS5vv0HID98Y1+BFNAHDKfI= -github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251125091810-0f15d56ca782/go.mod h1:AhHXfnrZ8Mxql05y4JUWt8ia6fTKruNdrcYEV6iEEBA= +github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251126143438-6cc7726dadb6 h1:oDIjI7IyHcFONm7a2ETtaTGp11yc+gZjRzeMbNsNaJw= +github.com/hyperledger-labs/fabric-smart-client v0.6.1-0.20251126143438-6cc7726dadb6/go.mod h1:Ri5zkzmnmUzOCwk1Hgj3imaiblVQS2bm5G90oyqIgLU= github.com/hyperledger/fabric-amcl v0.0.0-20230602173724-9e02669dceb2 h1:B1Nt8hKb//KvgGRprk0h1t4lCnwhE9/ryb1WqfZbV+M= github.com/hyperledger/fabric-amcl v0.0.0-20230602173724-9e02669dceb2/go.mod h1:X+DIyUsaTmalOpmpQfIvFZjKHQedrURQ5t4YqquX7lE= github.com/hyperledger/fabric-lib-go v1.1.3-0.20240523144151-25edd1eaf5f5 h1:RPWTL5wxAb+xDOrsCU3QYZP65305F8v3PaOyzdbPVMU= @@ -194,10 +196,10 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= -github.com/onsi/ginkgo/v2 v2.23.4 h1:ktYTpKJAVZnDT4VjxSbiBenUjmlL/5QkBEocaWXiQus= -github.com/onsi/ginkgo/v2 v2.23.4/go.mod h1:Bt66ApGPBFzHyR+JO10Zbt0Gsp4uWxu5mIOTusL46e8= -github.com/onsi/gomega v1.37.0 h1:CdEG8g0S133B4OswTDC/5XPSzE1OeP29QOioj2PID2Y= -github.com/onsi/gomega v1.37.0/go.mod h1:8D9+Txp43QWKhM24yyOBEdpkzN8FvJyAwecBgsU4KU0= +github.com/onsi/ginkgo/v2 v2.25.1 h1:Fwp6crTREKM+oA6Cz4MsO8RhKQzs2/gOIVOUscMAfZY= +github.com/onsi/ginkgo/v2 v2.25.1/go.mod h1:ppTWQ1dh9KM/F1XgpeRqelR+zHVwV81DGRSDnFxK7Sk= +github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A= +github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k= github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040= @@ -289,6 +291,8 @@ go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9E go.uber.org/zap v1.12.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= +go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= diff --git a/token/services/network/fabric/driver.go b/token/services/network/fabric/driver.go index 09ee09e53..11d633c22 100644 --- a/token/services/network/fabric/driver.go +++ b/token/services/network/fabric/driver.go @@ -25,6 +25,7 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/finality" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/lookup" "github.com/hyperledger-labs/fabric-token-sdk/token/services/tokens" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttxdb" "go.opentelemetry.io/otel/trace" ) @@ -65,6 +66,7 @@ func NewGenericDriver( tracerProvider trace.TracerProvider, identityProvider view.IdentityProvider, configService cdriver.ConfigService, + storeServiceManager ttxdb.StoreServiceManager, ) driver.Driver { keyTranslator := &keys.Translator{} return NewDriver( @@ -82,7 +84,16 @@ func NewGenericDriver( keyTranslator, finality.NewListenerManagerProvider(fnsProvider, tracerProvider, keyTranslator, config3.NewListenerManagerConfig(configService)), lookup.NewListenerManagerProvider(fnsProvider, tracerProvider, keyTranslator, config3.NewListenerManagerConfig(configService)), - endorsement.NewServiceProvider(fnsProvider, configProvider, viewManager, viewRegistry, identityProvider, keyTranslator), + endorsement.NewServiceProvider( + fnsProvider, + tmsProvider, + configProvider, + viewManager, + viewRegistry, + identityProvider, + keyTranslator, + storeServiceManager, + ), NewSetupListenerProvider(tmsProvider, tokensManager), config2.GenericDriver, ) diff --git a/token/services/network/fabric/endorsement/approval.go b/token/services/network/fabric/endorsement/approval.go deleted file mode 100644 index a7382bfdb..000000000 --- a/token/services/network/fabric/endorsement/approval.go +++ /dev/null @@ -1,308 +0,0 @@ -/* -Copyright IBM Corp. All Rights Reserved. - -SPDX-License-Identifier: Apache-2.0 -*/ - -package endorsement - -import ( - "context" - "time" - - "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" - fabric2 "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" - "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/services/endorser" - "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" - token2 "github.com/hyperledger-labs/fabric-token-sdk/token" - "github.com/hyperledger-labs/fabric-token-sdk/token/core/common" - driver2 "github.com/hyperledger-labs/fabric-token-sdk/token/driver" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/common/rws/translator" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/driver" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttxdb" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/utils" - "github.com/hyperledger-labs/fabric-token-sdk/token/token" -) - -type RequestApprovalView struct { - TMSID token2.TMSID - TxID driver.TxID - RequestRaw []byte - // RequestAnchor, if not nil it will instruct the approver to verify the token request using this anchor and not the transaction it. - // This is to be used only for testing. - RequestAnchor string - // Nonce, if not nil it will be appended to the messages to sign. - // This is to be used only for testing. - Nonce []byte - // Endorsers are the identities of the FSC node that play the role of endorser - Endorsers []view.Identity -} - -func (r *RequestApprovalView) Call(context view.Context) (interface{}, error) { - logger.DebugfContext(context.Context(), "request approval...") - - _, tx, err := endorser.NewTransaction( - context, - fabric2.WithCreator(r.TxID.Creator), - fabric2.WithNonce(r.TxID.Nonce), - ) - if err != nil { - return nil, errors.WithMessagef(err, "failed to create endorser transaction") - } - - tms, err := token2.GetManagementService(context, token2.WithTMSID(r.TMSID)) - if err != nil { - return nil, errors.WithMessagef(err, "no token management service for [%s]", r.TMSID) - } - tx.SetProposal(tms.Namespace(), "", InvokeFunction) - if err := tx.EndorseProposal(); err != nil { - return nil, errors.WithMessagef(err, "failed to endorse proposal") - } - if err := tx.SetTransientState("tmsID", tms.ID()); err != nil { - return nil, errors.WithMessagef(err, "failed to set TMS ID transient") - } - if err := tx.SetTransient("token_request", r.RequestRaw); err != nil { - return nil, errors.WithMessagef(err, "failed to set token request transient") - } - if len(r.RequestAnchor) != 0 { - if err := tx.SetTransient("RequestAnchor", []byte(r.RequestAnchor)); err != nil { - return nil, errors.WithMessagef(err, "failed to set token request transient") - } - } - if len(r.Nonce) != 0 { - if err := tx.SetTransient("Nonce", r.Nonce); err != nil { - return nil, errors.WithMessagef(err, "failed to set token request transient") - } - } - - logger.DebugfContext(context.Context(), "request endorsement on tx [%s] to [%v]...", tx.ID(), r.Endorsers) - _, err = context.RunView(endorser.NewParallelCollectEndorsementsOnProposalView( - tx, - r.Endorsers..., - ).WithTimeout(2 * time.Minute)) - if err != nil { - return nil, errors.WithMessagef(err, "failed to collect endorsements") - } - logger.DebugfContext(context.Context(), "request endorsement done") - - // Return envelope - env, err := tx.Envelope() - if err != nil { - return nil, errors.WithMessagef(err, "failed to retrieve envelope for endorsement") - } - logger.DebugfContext(context.Context(), "envelope ready") - - return env, nil -} - -type Translator interface { - AddPublicParamsDependency() error - CommitTokenRequest(raw []byte, storeHash bool) ([]byte, error) - Write(ctx context.Context, action any) error -} - -type TranslatorProviderFunc = func(txID string, namespace string, rws *fabric2.RWSet) (Translator, error) - -type RequestApprovalResponderView struct { - keyTranslator translator.KeyTranslator - getTranslator TranslatorProviderFunc -} - -func NewRequestApprovalResponderView(keyTranslator translator.KeyTranslator, getTranslator TranslatorProviderFunc) *RequestApprovalResponderView { - return &RequestApprovalResponderView{keyTranslator: keyTranslator, getTranslator: getTranslator} -} - -func (r *RequestApprovalResponderView) Call(context view.Context) (interface{}, error) { - // When the borrower runs the CollectEndorsementsView, at some point, the borrower sends the assembled transaction - // to the approver. Therefore, the approver waits to receive the transaction. - logger.DebugfContext(context.Context(), "Waiting for transaction on context [%s]", context.ID()) - tx, err := endorser.ReceiveTransaction(context) - if err != nil { - return nil, errors.WithMessagef(err, "failed to received transaction for approval") - } - logger.DebugfContext(context.Context(), "Received transaction [%s] for endorsement on context [%s]", tx.ID(), context.ID()) - defer logger.DebugfContext(context.Context(), "Return endorsement result for TX [%s]", tx.ID()) - raw, err := tx.Bytes() - if err != nil { - return nil, errors.WithMessagef(err, "failed to marshal transaction [%s]", tx.ID()) - } - - logger.DebugfContext(context.Context(), "Respond to request of approval for tx [%s][%s]", tx.ID(), utils.Hashable(raw)) - - var tmsID token2.TMSID - if err := tx.GetTransientState("tmsID", &tmsID); err != nil { - return nil, errors.WithMessagef(err, "failed to get TMS ID from transient [%s]", tx.ID()) - } - requestRaw := tx.GetTransient("token_request") - if len(requestRaw) == 0 { - return nil, errors.Errorf("failed to get token request from transient [%s], it is empty", tx.ID()) - } - requestAnchor := string(tx.GetTransient("RequestAnchor")) - if len(requestAnchor) == 0 { - requestAnchor = tx.ID() - } - - logger.DebugfContext(context.Context(), "evaluate token request on TMS [%s]", tmsID) - tms, err := token2.GetManagementService(context, token2.WithTMSID(tmsID)) - if err != nil { - return nil, errors.WithMessagef(err, "cannot find TMS for [%s]", tmsID) - } - - rws, err := tx.RWSet() - if err != nil { - return nil, errors.WithMessagef(err, "failed to get rws for tx [%s]", tx.ID()) - } - defer rws.Done() - - fns, err := fabric2.GetFabricNetworkService(context, tms.Network()) - if err != nil { - return nil, errors.WithMessagef(err, "cannot find fabric network for [%s]", tms.Network()) - } - - // validate token request - logger.DebugfContext(context.Context(), "Validate TX [%s]", tx.ID()) - actions, validationMetadata, err := r.validate(context, tms, tx, requestAnchor, requestRaw, func(id token.ID) ([]byte, error) { - key, err := r.keyTranslator.CreateOutputKey(id.TxId, id.Index) - if err != nil { - return nil, errors.WithMessagef(err, "failed to create token key for id [%s]", id) - } - return rws.GetDirectState(tms.Namespace(), key) - }) - - if err != nil { - return nil, err - } - - // endorse - logger.DebugfContext(context.Context(), "Endorse TX [%s]", tx.ID()) - endorserID, err := r.endorserID(tms, fns) - if err != nil { - return nil, err - } - - // write actions into the transaction - logger.DebugfContext(context.Context(), "Translate TX [%s]", tx.ID()) - err = r.translate(context.Context(), tms, tx, validationMetadata, rws, actions...) - if err != nil { - return nil, err - } - - logger.DebugfContext(context.Context(), "Endorse proposal for TX [%s]", tx.ID()) - endorsementResult, err := context.RunView(endorser.NewEndorsementOnProposalResponderView(tx, endorserID)) - if err != nil { - logger.Errorf("failed to respond to endorsement [%s]", err) - } - logger.DebugfContext(context.Context(), "Finished endorsement on TX [%s]", tx.ID()) - return endorsementResult, err -} - -func (r *RequestApprovalResponderView) translate( - ctx context.Context, - tms *token2.ManagementService, - tx *endorser.Transaction, - validationMetadata map[string][]byte, - rws *fabric2.RWSet, - actions ...any, -) error { - // prepare the rws as usual - txID := tx.ID() - w, err := r.getTranslator(txID, tms.Namespace(), rws) - if err != nil { - return errors.Wrapf(err, "failed to get translator for tx [%s]", tx.ID()) - } - for _, action := range actions { - if err := w.Write(ctx, action); err != nil { - return errors.Wrapf(err, "failed to write token action for tx [%s]", txID) - } - } - err = w.AddPublicParamsDependency() - if err != nil { - return errors.Wrapf(err, "failed to add public params dependency") - } - _, err = w.CommitTokenRequest(validationMetadata[common.TokenRequestToSign], true) - if err != nil { - return errors.Wrapf(err, "failed to write token request") - } - return nil -} - -func (r *RequestApprovalResponderView) validate( - context view.Context, - tms *token2.ManagementService, - tx *endorser.Transaction, - anchor string, - requestRaw []byte, - getState driver2.GetStateFnc, -) ([]any, map[string][]byte, error) { - defer logger.DebugfContext(context.Context(), "Finished validation of TX [%s]", tx.ID()) - logger.DebugfContext(context.Context(), "Get validator for TX [%s]", tx.ID()) - validator, err := tms.Validator() - if err != nil { - return nil, nil, errors.WithMessagef(err, "failed to get validator [%s:%s]", tms.Network(), tms.Channel()) - } - logger.DebugfContext(context.Context(), "Unmarshal and verify with metadata for TX [%s]", tx.ID()) - actions, meta, err := validator.UnmarshallAndVerifyWithMetadata( - context.Context(), - token2.NewLedgerFromGetter(getState), - token2.RequestAnchor(anchor), - requestRaw, - ) - if err != nil { - return nil, nil, errors.WithMessagef(err, "failed to verify token request for [%s]", tx.ID()) - } - db, err := ttxdb.GetByTMSId(context, tms.ID()) - if err != nil { - return nil, nil, errors.WithMessagef(err, "failed to retrieve db [%s]", tms.ID()) - } - logger.DebugfContext(context.Context(), "Append validation record for TX [%s]", tx.ID()) - if err := db.AppendValidationRecord( - context.Context(), - tx.ID(), - requestRaw, - meta, - tms.PublicParametersManager().PublicParamsHash(), - ); err != nil { - return nil, nil, errors.WithMessagef(err, "failed to append metadata for [%s]", tx.ID()) - } - return actions, meta, nil -} - -func (r *RequestApprovalResponderView) endorserID(tms *token2.ManagementService, fns *fabric2.NetworkService) (view.Identity, error) { - var endorserIDLabel string - if err := tms.Configuration().UnmarshalKey("services.network.fabric.fsc_endorsement.id", &endorserIDLabel); err != nil { - return nil, errors.WithMessagef(err, "failed to load endorserID") - } - var endorserID view.Identity - if len(endorserIDLabel) == 0 { - endorserID = fns.LocalMembership().DefaultIdentity() - } else { - var err error - endorserID, err = fns.LocalMembership().GetIdentityByID(endorserIDLabel) - if err != nil { - return nil, errors.WithMessagef(err, "cannot find local endorser identity for [%s]", endorserIDLabel) - } - } - if endorserID.IsNone() { - return nil, errors.Errorf("cannot find local endorser identity for [%s]", endorserIDLabel) - } - if _, err := fns.SignerService().GetSigner(endorserID); err != nil { - return nil, errors.WithMessagef(err, "cannot find fabric signer for identity [%s:%s]", endorserIDLabel, endorserID) - } - return endorserID, nil -} - -type RWSWrapper struct { - Stub *fabric2.RWSet -} - -func (rwset *RWSWrapper) SetState(namespace string, key string, value []byte) error { - return rwset.Stub.SetState(namespace, key, value) -} - -func (rwset *RWSWrapper) GetState(namespace string, key string) ([]byte, error) { - return rwset.Stub.GetState(namespace, key) -} - -func (rwset *RWSWrapper) DeleteState(namespace string, key string) error { - return rwset.Stub.DeleteState(namespace, key) -} diff --git a/token/services/network/fabric/endorsement/chaincode.go b/token/services/network/fabric/endorsement/chaincode.go index 49feab3be..d5123fd5e 100644 --- a/token/services/network/fabric/endorsement/chaincode.go +++ b/token/services/network/fabric/endorsement/chaincode.go @@ -14,7 +14,10 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/driver" ) -const InvokeFunction = "invoke" +const ( + // InvokeFunction is the name of the function to use to request the approval of a token request + InvokeFunction = "invoke" +) type ChaincodeEndorsementService struct { TMSID token2.TMSID diff --git a/token/services/network/fabric/endorsement/fsc/deps.go b/token/services/network/fabric/endorsement/fsc/deps.go new file mode 100644 index 000000000..b36d3184a --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/deps.go @@ -0,0 +1,77 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package fsc + +import ( + "context" + "time" + + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/services/endorser" + "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" + "github.com/hyperledger-labs/fabric-token-sdk/token" +) + +//go:generate counterfeiter -o mock/fabric_envelope.go -fake-name Envelope . Envelope +type Envelope = driver.Envelope + +//go:generate counterfeiter -o mock/fabric_rws.go -fake-name FabricRWSet . FabricRWSet +type FabricRWSet = driver.RWSet + +//go:generate counterfeiter -o mock/tmsp.go -fake-name TokenManagementSystemProvider . TokenManagementSystemProvider +type TokenManagementSystemProvider interface { + GetManagementService(opts ...token.ServiceOption) (*token.ManagementService, error) +} + +//go:generate counterfeiter -o mock/translator.go -fake-name Translator . Translator +type Translator interface { + AddPublicParamsDependency() error + CommitTokenRequest(raw []byte, storeHash bool) ([]byte, error) + Write(ctx context.Context, action any) error +} + +type TranslatorProviderFunc = func(txID string, namespace string, rws *fabric.RWSet) (Translator, error) + +// EndorserService defines the behaviors of the FSC's fabric endorser service that are needed by this package +// +//go:generate counterfeiter -o mock/endorser_service.go -fake-name EndorserService . EndorserService +type EndorserService interface { + NewTransaction(context view.Context, opts ...fabric.TransactionOption) (*endorser.Transaction, error) + ReceiveTx(ctx view.Context) (*endorser.Transaction, error) + CollectEndorsements(ctx view.Context, tx *endorser.Transaction, timeOut time.Duration, parties ...view.Identity) error + Endorse(ctx view.Context, tx *endorser.Transaction, identities ...view.Identity) (any, error) + EndorserID(tmsID token.TMSID) (view.Identity, error) +} + +// Context is an alias for view.Context +// +//go:generate counterfeiter -o mock/ctx.go -fake-name Context . Context +type Context = view.Context + +// FabricTransaction is an alias for driver.Transaction +// +//go:generate counterfeiter -o mock/fabric_transaction.go -fake-name FabricTransaction . FabricTransaction +type FabricTransaction = driver.Transaction + +type IdentityProvider interface { + Identity(string) view.Identity +} + +type ViewManager interface { + InitiateView(view view.View, ctx context.Context) (interface{}, error) +} + +type ViewRegistry interface { + RegisterResponder(responder view.View, initiatedBy interface{}) error +} + +// NamespaceTxProcessor models a namespace transaction processor. +type NamespaceTxProcessor interface { + // EnableTxProcessing signals the backend to process all the transactions for the given tms id + EnableTxProcessing(tmsID token.TMSID) error +} diff --git a/token/services/network/fabric/endorsement/fsc/errors.go b/token/services/network/fabric/endorsement/fsc/errors.go new file mode 100644 index 000000000..70e592749 --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/errors.go @@ -0,0 +1,24 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package fsc + +import ( + "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" +) + +var ( + // ErrInvalidTransient signals that the transient values are invalid + ErrInvalidTransient = errors.New("invalid transient") + // ErrInvalidProposal signals that the proposal is invalid + ErrInvalidProposal = errors.New("invalid proposal") + // ErrReceivedProposal signals that an error occurred when receiving the proposal + ErrReceivedProposal = errors.New("failed to received proposal") + // ErrValidateProposal signals a failure in validating the proposal + ErrValidateProposal = errors.New("failed to validate proposal") + // ErrEndorseProposal signals a failure in endorsing the proposal + ErrEndorseProposal = errors.New("failed to endorse proposal") +) diff --git a/token/services/network/fabric/endorsement/fsc/initiator.go b/token/services/network/fabric/endorsement/fsc/initiator.go new file mode 100644 index 000000000..59ed6e49c --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/initiator.go @@ -0,0 +1,95 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package fsc + +import ( + "time" + + "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" + "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" + "github.com/hyperledger-labs/fabric-token-sdk/token" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/driver" +) + +// RequestApprovalView is the initiator of the request approval protocol +type RequestApprovalView struct { + TMSID token.TMSID + TxID driver.TxID + RequestRaw []byte + // Nonce, if not nil it will be appended to the messages to sign. + // This is to be used only for testing. + Nonce []byte + // Endorsers are the identities of the FSC node that play the role of endorser + Endorsers []view.Identity + + // EndorserService is the endorser service + EndorserService EndorserService + // TokenManagementSystemProvider + TokenManagementSystemProvider TokenManagementSystemProvider +} + +// NewRequestApprovalView returns a new instance of RequestApprovalView +func NewRequestApprovalView( + TMSID token.TMSID, + txID driver.TxID, + requestRaw []byte, + nonce []byte, + endorsers []view.Identity, + endorserService EndorserService, +) *RequestApprovalView { + return &RequestApprovalView{ + TMSID: TMSID, + TxID: txID, + RequestRaw: requestRaw, + Nonce: nonce, + Endorsers: endorsers, + EndorserService: endorserService, + } +} + +func (r *RequestApprovalView) Call(ctx view.Context) (any, error) { + logger.DebugfContext(ctx.Context(), "request approval from tms id [%s]", r.TMSID) + + tx, err := r.EndorserService.NewTransaction( + ctx, + fabric.WithCreator(r.TxID.Creator), + fabric.WithNonce(r.TxID.Nonce), + ) + if err != nil { + return nil, errors.WithMessagef(err, "failed to create endorser transaction") + } + + tx.SetProposal(r.TMSID.Namespace, ChaincodeVersion, InvokeFunction) + if err := tx.EndorseProposal(); err != nil { + return nil, errors.WithMessagef(err, "failed to endorse proposal") + } + + // transient fields + if err := tx.SetTransientState(TransientTMSIDKey, r.TMSID); err != nil { + return nil, errors.WithMessagef(err, "failed to set TMS ID transient") + } + if err := tx.SetTransient(TransientTokenRequestKey, r.RequestRaw); err != nil { + return nil, errors.WithMessagef(err, "failed to set token request transient") + } + + logger.DebugfContext(ctx.Context(), "request endorsement on tx [%s] to [%v]...", tx.ID(), r.Endorsers) + err = r.EndorserService.CollectEndorsements(ctx, tx, 2*time.Minute, r.Endorsers...) + if err != nil { + return nil, errors.WithMessagef(err, "failed to collect endorsements") + } + logger.DebugfContext(ctx.Context(), "request endorsement done") + + // Return envelope + env, err := tx.Envelope() + if err != nil { + return nil, errors.WithMessagef(err, "failed to retrieve envelope for endorsement") + } + logger.DebugfContext(ctx.Context(), "envelope ready") + + return env, nil +} diff --git a/token/services/network/fabric/endorsement/fsc/initiator_test.go b/token/services/network/fabric/endorsement/fsc/initiator_test.go new file mode 100644 index 000000000..e654d9f2a --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/initiator_test.go @@ -0,0 +1,179 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package fsc_test + +import ( + "encoding/json" + "testing" + + "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/services/endorser" + "github.com/hyperledger-labs/fabric-token-sdk/token" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/tokenapi" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +type MockNewRequestApprovalView struct { + view *fsc.RequestApprovalView + ctx *mock.Context + fabricTx *mock.FabricTransaction + tmsID token.TMSID + es *mock.EndorserService + transientMap driver.TransientMap + tmsIDRaw []byte + requestRaw []byte + env *fabric.Envelope +} + +func mockNewRequestApprovalView(t *testing.T, overrideTMSID *token.TMSID) *MockNewRequestApprovalView { + t.Helper() + + ctx := &mock.Context{} + ctx.ContextReturns(t.Context()) + es := &mock.EndorserService{} + fabricTx := &mock.FabricTransaction{} + fabricTx.IDReturns("a_tx_id") + tmsID := token.TMSID{ + Network: "a_network", + Channel: "a_channel", + Namespace: "a_namespace", + } + if overrideTMSID != nil { + tmsID = *overrideTMSID + } + tmsIDRaw, err := json.Marshal(tmsID) + require.NoError(t, err) + transientMap := driver.TransientMap{} + fabricTx.TransientReturns(transientMap) + env := &mock.Envelope{} + fabricTx.EnvelopeReturns(env, nil) + + es.NewTransactionReturns(&endorser.Transaction{ + Provider: ctx, + Transaction: fabric.NewTransaction(nil, fabricTx), + }, nil) + tmsp := &mock.TokenManagementSystemProvider{} + tms, validator := tokenapi.NewMockedManagementServiceWithValidation(t, tmsID) + validator.VerifyTokenRequestFromRawReturns(nil, nil, nil) + tmsp.GetManagementServiceReturns(tms, nil) + + storage := &mock.Storage{} + storageProvider := &mock.StorageProvider{} + storageProvider.GetStorageReturns(storage, nil) + storage.AppendValidationRecordReturns(nil) + + requestRaw := []byte("a_request") + + view := fsc.NewRequestApprovalView( + tmsID, + driver.TxID{}, + requestRaw, + nil, + nil, + es, + ) + return &MockNewRequestApprovalView{ + view: view, + ctx: ctx, + fabricTx: fabricTx, + es: es, + tmsID: tmsID, + tmsIDRaw: tmsIDRaw, + transientMap: transientMap, + requestRaw: requestRaw, + env: fabric.NewEnvelope(env), + } +} + +func TestRequestApprovalView(t *testing.T) { + type testCase struct { + name string + setup func() *MockNewRequestApprovalView + verify func(m *MockNewRequestApprovalView, res any) + expectError bool + expectErrorType error + expectErrContain string + } + + testCases := []testCase{ + { + name: "Success", + setup: func() *MockNewRequestApprovalView { + mock := mockNewRequestApprovalView(t, nil) + return mock + }, + verify: func(m *MockNewRequestApprovalView, res any) { + assert.Equal(t, 1, m.fabricTx.SetProposalCallCount()) + namespace, version, functionName, args := m.fabricTx.SetProposalArgsForCall(0) + assert.Equal(t, m.tmsID.Namespace, namespace) + assert.Equal(t, fsc.ChaincodeVersion, version) + assert.Equal(t, fsc.InvokeFunction, functionName) + assert.Empty(t, args) + + assert.Len(t, m.transientMap, 2) + assert.Equal(t, m.tmsIDRaw, m.transientMap[fsc.TransientTMSIDKey]) + assert.Equal(t, m.requestRaw, m.transientMap[fsc.TransientTokenRequestKey]) + assert.Equal(t, m.env, res) + }, + expectError: false, + }, + { + name: "failed NewTransaction", + setup: func() *MockNewRequestApprovalView { + mock := mockNewRequestApprovalView(t, nil) + mock.es.NewTransactionReturns(nil, errors.New("failed NewTransaction")) + return mock + }, + expectError: true, + expectErrContain: "failed NewTransaction", + }, + { + name: "failed EndorseProposal", + setup: func() *MockNewRequestApprovalView { + mock := mockNewRequestApprovalView(t, nil) + mock.fabricTx.EndorseProposalReturns(errors.New("failed EndorseProposal")) + return mock + }, + expectError: true, + expectErrContain: "failed EndorseProposal", + }, + { + name: "failed CollectEndorsements", + setup: func() *MockNewRequestApprovalView { + mock := mockNewRequestApprovalView(t, nil) + mock.es.CollectEndorsementsReturns(errors.New("failed CollectEndorsements")) + return mock + }, + expectError: true, + expectErrContain: "failed CollectEndorsements", + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + m := tc.setup() + res, err := m.view.Call(m.ctx) + if tc.expectError { + require.Error(t, err) + if tc.expectErrorType != nil { + assert.ErrorIs(t, err, tc.expectErrorType) + } + assert.Contains(t, err.Error(), tc.expectErrContain) + } else { + require.NoError(t, err) + } + if tc.verify != nil { + tc.verify(m, res) + } + }) + } +} diff --git a/token/services/network/fabric/endorsement/fsc/mock/ctx.go b/token/services/network/fabric/endorsement/fsc/mock/ctx.go new file mode 100644 index 000000000..72157580e --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/mock/ctx.go @@ -0,0 +1,885 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" + "go.opentelemetry.io/otel/trace" +) + +type Context struct { + ContextStub func() context.Context + contextMutex sync.RWMutex + contextArgsForCall []struct { + } + contextReturns struct { + result1 context.Context + } + contextReturnsOnCall map[int]struct { + result1 context.Context + } + GetServiceStub func(interface{}) (interface{}, error) + getServiceMutex sync.RWMutex + getServiceArgsForCall []struct { + arg1 interface{} + } + getServiceReturns struct { + result1 interface{} + result2 error + } + getServiceReturnsOnCall map[int]struct { + result1 interface{} + result2 error + } + GetSessionStub func(view.View, view.Identity, ...view.View) (view.Session, error) + getSessionMutex sync.RWMutex + getSessionArgsForCall []struct { + arg1 view.View + arg2 view.Identity + arg3 []view.View + } + getSessionReturns struct { + result1 view.Session + result2 error + } + getSessionReturnsOnCall map[int]struct { + result1 view.Session + result2 error + } + GetSessionByIDStub func(string, view.Identity) (view.Session, error) + getSessionByIDMutex sync.RWMutex + getSessionByIDArgsForCall []struct { + arg1 string + arg2 view.Identity + } + getSessionByIDReturns struct { + result1 view.Session + result2 error + } + getSessionByIDReturnsOnCall map[int]struct { + result1 view.Session + result2 error + } + IDStub func() string + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 string + } + iDReturnsOnCall map[int]struct { + result1 string + } + InitiatorStub func() view.View + initiatorMutex sync.RWMutex + initiatorArgsForCall []struct { + } + initiatorReturns struct { + result1 view.View + } + initiatorReturnsOnCall map[int]struct { + result1 view.View + } + IsMeStub func(view.Identity) bool + isMeMutex sync.RWMutex + isMeArgsForCall []struct { + arg1 view.Identity + } + isMeReturns struct { + result1 bool + } + isMeReturnsOnCall map[int]struct { + result1 bool + } + MeStub func() view.Identity + meMutex sync.RWMutex + meArgsForCall []struct { + } + meReturns struct { + result1 view.Identity + } + meReturnsOnCall map[int]struct { + result1 view.Identity + } + OnErrorStub func(func()) + onErrorMutex sync.RWMutex + onErrorArgsForCall []struct { + arg1 func() + } + RunViewStub func(view.View, ...view.RunViewOption) (interface{}, error) + runViewMutex sync.RWMutex + runViewArgsForCall []struct { + arg1 view.View + arg2 []view.RunViewOption + } + runViewReturns struct { + result1 interface{} + result2 error + } + runViewReturnsOnCall map[int]struct { + result1 interface{} + result2 error + } + SessionStub func() view.Session + sessionMutex sync.RWMutex + sessionArgsForCall []struct { + } + sessionReturns struct { + result1 view.Session + } + sessionReturnsOnCall map[int]struct { + result1 view.Session + } + StartSpanFromStub func(context.Context, string, ...trace.SpanStartOption) (context.Context, trace.Span) + startSpanFromMutex sync.RWMutex + startSpanFromArgsForCall []struct { + arg1 context.Context + arg2 string + arg3 []trace.SpanStartOption + } + startSpanFromReturns struct { + result1 context.Context + result2 trace.Span + } + startSpanFromReturnsOnCall map[int]struct { + result1 context.Context + result2 trace.Span + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Context) Context() context.Context { + fake.contextMutex.Lock() + ret, specificReturn := fake.contextReturnsOnCall[len(fake.contextArgsForCall)] + fake.contextArgsForCall = append(fake.contextArgsForCall, struct { + }{}) + stub := fake.ContextStub + fakeReturns := fake.contextReturns + fake.recordInvocation("Context", []interface{}{}) + fake.contextMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Context) ContextCallCount() int { + fake.contextMutex.RLock() + defer fake.contextMutex.RUnlock() + return len(fake.contextArgsForCall) +} + +func (fake *Context) ContextCalls(stub func() context.Context) { + fake.contextMutex.Lock() + defer fake.contextMutex.Unlock() + fake.ContextStub = stub +} + +func (fake *Context) ContextReturns(result1 context.Context) { + fake.contextMutex.Lock() + defer fake.contextMutex.Unlock() + fake.ContextStub = nil + fake.contextReturns = struct { + result1 context.Context + }{result1} +} + +func (fake *Context) ContextReturnsOnCall(i int, result1 context.Context) { + fake.contextMutex.Lock() + defer fake.contextMutex.Unlock() + fake.ContextStub = nil + if fake.contextReturnsOnCall == nil { + fake.contextReturnsOnCall = make(map[int]struct { + result1 context.Context + }) + } + fake.contextReturnsOnCall[i] = struct { + result1 context.Context + }{result1} +} + +func (fake *Context) GetService(arg1 interface{}) (interface{}, error) { + fake.getServiceMutex.Lock() + ret, specificReturn := fake.getServiceReturnsOnCall[len(fake.getServiceArgsForCall)] + fake.getServiceArgsForCall = append(fake.getServiceArgsForCall, struct { + arg1 interface{} + }{arg1}) + stub := fake.GetServiceStub + fakeReturns := fake.getServiceReturns + fake.recordInvocation("GetService", []interface{}{arg1}) + fake.getServiceMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Context) GetServiceCallCount() int { + fake.getServiceMutex.RLock() + defer fake.getServiceMutex.RUnlock() + return len(fake.getServiceArgsForCall) +} + +func (fake *Context) GetServiceCalls(stub func(interface{}) (interface{}, error)) { + fake.getServiceMutex.Lock() + defer fake.getServiceMutex.Unlock() + fake.GetServiceStub = stub +} + +func (fake *Context) GetServiceArgsForCall(i int) interface{} { + fake.getServiceMutex.RLock() + defer fake.getServiceMutex.RUnlock() + argsForCall := fake.getServiceArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *Context) GetServiceReturns(result1 interface{}, result2 error) { + fake.getServiceMutex.Lock() + defer fake.getServiceMutex.Unlock() + fake.GetServiceStub = nil + fake.getServiceReturns = struct { + result1 interface{} + result2 error + }{result1, result2} +} + +func (fake *Context) GetServiceReturnsOnCall(i int, result1 interface{}, result2 error) { + fake.getServiceMutex.Lock() + defer fake.getServiceMutex.Unlock() + fake.GetServiceStub = nil + if fake.getServiceReturnsOnCall == nil { + fake.getServiceReturnsOnCall = make(map[int]struct { + result1 interface{} + result2 error + }) + } + fake.getServiceReturnsOnCall[i] = struct { + result1 interface{} + result2 error + }{result1, result2} +} + +func (fake *Context) GetSession(arg1 view.View, arg2 view.Identity, arg3 ...view.View) (view.Session, error) { + fake.getSessionMutex.Lock() + ret, specificReturn := fake.getSessionReturnsOnCall[len(fake.getSessionArgsForCall)] + fake.getSessionArgsForCall = append(fake.getSessionArgsForCall, struct { + arg1 view.View + arg2 view.Identity + arg3 []view.View + }{arg1, arg2, arg3}) + stub := fake.GetSessionStub + fakeReturns := fake.getSessionReturns + fake.recordInvocation("GetSession", []interface{}{arg1, arg2, arg3}) + fake.getSessionMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Context) GetSessionCallCount() int { + fake.getSessionMutex.RLock() + defer fake.getSessionMutex.RUnlock() + return len(fake.getSessionArgsForCall) +} + +func (fake *Context) GetSessionCalls(stub func(view.View, view.Identity, ...view.View) (view.Session, error)) { + fake.getSessionMutex.Lock() + defer fake.getSessionMutex.Unlock() + fake.GetSessionStub = stub +} + +func (fake *Context) GetSessionArgsForCall(i int) (view.View, view.Identity, []view.View) { + fake.getSessionMutex.RLock() + defer fake.getSessionMutex.RUnlock() + argsForCall := fake.getSessionArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *Context) GetSessionReturns(result1 view.Session, result2 error) { + fake.getSessionMutex.Lock() + defer fake.getSessionMutex.Unlock() + fake.GetSessionStub = nil + fake.getSessionReturns = struct { + result1 view.Session + result2 error + }{result1, result2} +} + +func (fake *Context) GetSessionReturnsOnCall(i int, result1 view.Session, result2 error) { + fake.getSessionMutex.Lock() + defer fake.getSessionMutex.Unlock() + fake.GetSessionStub = nil + if fake.getSessionReturnsOnCall == nil { + fake.getSessionReturnsOnCall = make(map[int]struct { + result1 view.Session + result2 error + }) + } + fake.getSessionReturnsOnCall[i] = struct { + result1 view.Session + result2 error + }{result1, result2} +} + +func (fake *Context) GetSessionByID(arg1 string, arg2 view.Identity) (view.Session, error) { + fake.getSessionByIDMutex.Lock() + ret, specificReturn := fake.getSessionByIDReturnsOnCall[len(fake.getSessionByIDArgsForCall)] + fake.getSessionByIDArgsForCall = append(fake.getSessionByIDArgsForCall, struct { + arg1 string + arg2 view.Identity + }{arg1, arg2}) + stub := fake.GetSessionByIDStub + fakeReturns := fake.getSessionByIDReturns + fake.recordInvocation("GetSessionByID", []interface{}{arg1, arg2}) + fake.getSessionByIDMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Context) GetSessionByIDCallCount() int { + fake.getSessionByIDMutex.RLock() + defer fake.getSessionByIDMutex.RUnlock() + return len(fake.getSessionByIDArgsForCall) +} + +func (fake *Context) GetSessionByIDCalls(stub func(string, view.Identity) (view.Session, error)) { + fake.getSessionByIDMutex.Lock() + defer fake.getSessionByIDMutex.Unlock() + fake.GetSessionByIDStub = stub +} + +func (fake *Context) GetSessionByIDArgsForCall(i int) (string, view.Identity) { + fake.getSessionByIDMutex.RLock() + defer fake.getSessionByIDMutex.RUnlock() + argsForCall := fake.getSessionByIDArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Context) GetSessionByIDReturns(result1 view.Session, result2 error) { + fake.getSessionByIDMutex.Lock() + defer fake.getSessionByIDMutex.Unlock() + fake.GetSessionByIDStub = nil + fake.getSessionByIDReturns = struct { + result1 view.Session + result2 error + }{result1, result2} +} + +func (fake *Context) GetSessionByIDReturnsOnCall(i int, result1 view.Session, result2 error) { + fake.getSessionByIDMutex.Lock() + defer fake.getSessionByIDMutex.Unlock() + fake.GetSessionByIDStub = nil + if fake.getSessionByIDReturnsOnCall == nil { + fake.getSessionByIDReturnsOnCall = make(map[int]struct { + result1 view.Session + result2 error + }) + } + fake.getSessionByIDReturnsOnCall[i] = struct { + result1 view.Session + result2 error + }{result1, result2} +} + +func (fake *Context) ID() string { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Context) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *Context) IDCalls(stub func() string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *Context) IDReturns(result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 string + }{result1} +} + +func (fake *Context) IDReturnsOnCall(i int, result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *Context) Initiator() view.View { + fake.initiatorMutex.Lock() + ret, specificReturn := fake.initiatorReturnsOnCall[len(fake.initiatorArgsForCall)] + fake.initiatorArgsForCall = append(fake.initiatorArgsForCall, struct { + }{}) + stub := fake.InitiatorStub + fakeReturns := fake.initiatorReturns + fake.recordInvocation("Initiator", []interface{}{}) + fake.initiatorMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Context) InitiatorCallCount() int { + fake.initiatorMutex.RLock() + defer fake.initiatorMutex.RUnlock() + return len(fake.initiatorArgsForCall) +} + +func (fake *Context) InitiatorCalls(stub func() view.View) { + fake.initiatorMutex.Lock() + defer fake.initiatorMutex.Unlock() + fake.InitiatorStub = stub +} + +func (fake *Context) InitiatorReturns(result1 view.View) { + fake.initiatorMutex.Lock() + defer fake.initiatorMutex.Unlock() + fake.InitiatorStub = nil + fake.initiatorReturns = struct { + result1 view.View + }{result1} +} + +func (fake *Context) InitiatorReturnsOnCall(i int, result1 view.View) { + fake.initiatorMutex.Lock() + defer fake.initiatorMutex.Unlock() + fake.InitiatorStub = nil + if fake.initiatorReturnsOnCall == nil { + fake.initiatorReturnsOnCall = make(map[int]struct { + result1 view.View + }) + } + fake.initiatorReturnsOnCall[i] = struct { + result1 view.View + }{result1} +} + +func (fake *Context) IsMe(arg1 view.Identity) bool { + fake.isMeMutex.Lock() + ret, specificReturn := fake.isMeReturnsOnCall[len(fake.isMeArgsForCall)] + fake.isMeArgsForCall = append(fake.isMeArgsForCall, struct { + arg1 view.Identity + }{arg1}) + stub := fake.IsMeStub + fakeReturns := fake.isMeReturns + fake.recordInvocation("IsMe", []interface{}{arg1}) + fake.isMeMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Context) IsMeCallCount() int { + fake.isMeMutex.RLock() + defer fake.isMeMutex.RUnlock() + return len(fake.isMeArgsForCall) +} + +func (fake *Context) IsMeCalls(stub func(view.Identity) bool) { + fake.isMeMutex.Lock() + defer fake.isMeMutex.Unlock() + fake.IsMeStub = stub +} + +func (fake *Context) IsMeArgsForCall(i int) view.Identity { + fake.isMeMutex.RLock() + defer fake.isMeMutex.RUnlock() + argsForCall := fake.isMeArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *Context) IsMeReturns(result1 bool) { + fake.isMeMutex.Lock() + defer fake.isMeMutex.Unlock() + fake.IsMeStub = nil + fake.isMeReturns = struct { + result1 bool + }{result1} +} + +func (fake *Context) IsMeReturnsOnCall(i int, result1 bool) { + fake.isMeMutex.Lock() + defer fake.isMeMutex.Unlock() + fake.IsMeStub = nil + if fake.isMeReturnsOnCall == nil { + fake.isMeReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isMeReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *Context) Me() view.Identity { + fake.meMutex.Lock() + ret, specificReturn := fake.meReturnsOnCall[len(fake.meArgsForCall)] + fake.meArgsForCall = append(fake.meArgsForCall, struct { + }{}) + stub := fake.MeStub + fakeReturns := fake.meReturns + fake.recordInvocation("Me", []interface{}{}) + fake.meMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Context) MeCallCount() int { + fake.meMutex.RLock() + defer fake.meMutex.RUnlock() + return len(fake.meArgsForCall) +} + +func (fake *Context) MeCalls(stub func() view.Identity) { + fake.meMutex.Lock() + defer fake.meMutex.Unlock() + fake.MeStub = stub +} + +func (fake *Context) MeReturns(result1 view.Identity) { + fake.meMutex.Lock() + defer fake.meMutex.Unlock() + fake.MeStub = nil + fake.meReturns = struct { + result1 view.Identity + }{result1} +} + +func (fake *Context) MeReturnsOnCall(i int, result1 view.Identity) { + fake.meMutex.Lock() + defer fake.meMutex.Unlock() + fake.MeStub = nil + if fake.meReturnsOnCall == nil { + fake.meReturnsOnCall = make(map[int]struct { + result1 view.Identity + }) + } + fake.meReturnsOnCall[i] = struct { + result1 view.Identity + }{result1} +} + +func (fake *Context) OnError(arg1 func()) { + fake.onErrorMutex.Lock() + fake.onErrorArgsForCall = append(fake.onErrorArgsForCall, struct { + arg1 func() + }{arg1}) + stub := fake.OnErrorStub + fake.recordInvocation("OnError", []interface{}{arg1}) + fake.onErrorMutex.Unlock() + if stub != nil { + fake.OnErrorStub(arg1) + } +} + +func (fake *Context) OnErrorCallCount() int { + fake.onErrorMutex.RLock() + defer fake.onErrorMutex.RUnlock() + return len(fake.onErrorArgsForCall) +} + +func (fake *Context) OnErrorCalls(stub func(func())) { + fake.onErrorMutex.Lock() + defer fake.onErrorMutex.Unlock() + fake.OnErrorStub = stub +} + +func (fake *Context) OnErrorArgsForCall(i int) func() { + fake.onErrorMutex.RLock() + defer fake.onErrorMutex.RUnlock() + argsForCall := fake.onErrorArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *Context) RunView(arg1 view.View, arg2 ...view.RunViewOption) (interface{}, error) { + fake.runViewMutex.Lock() + ret, specificReturn := fake.runViewReturnsOnCall[len(fake.runViewArgsForCall)] + fake.runViewArgsForCall = append(fake.runViewArgsForCall, struct { + arg1 view.View + arg2 []view.RunViewOption + }{arg1, arg2}) + stub := fake.RunViewStub + fakeReturns := fake.runViewReturns + fake.recordInvocation("RunView", []interface{}{arg1, arg2}) + fake.runViewMutex.Unlock() + if stub != nil { + return stub(arg1, arg2...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Context) RunViewCallCount() int { + fake.runViewMutex.RLock() + defer fake.runViewMutex.RUnlock() + return len(fake.runViewArgsForCall) +} + +func (fake *Context) RunViewCalls(stub func(view.View, ...view.RunViewOption) (interface{}, error)) { + fake.runViewMutex.Lock() + defer fake.runViewMutex.Unlock() + fake.RunViewStub = stub +} + +func (fake *Context) RunViewArgsForCall(i int) (view.View, []view.RunViewOption) { + fake.runViewMutex.RLock() + defer fake.runViewMutex.RUnlock() + argsForCall := fake.runViewArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Context) RunViewReturns(result1 interface{}, result2 error) { + fake.runViewMutex.Lock() + defer fake.runViewMutex.Unlock() + fake.RunViewStub = nil + fake.runViewReturns = struct { + result1 interface{} + result2 error + }{result1, result2} +} + +func (fake *Context) RunViewReturnsOnCall(i int, result1 interface{}, result2 error) { + fake.runViewMutex.Lock() + defer fake.runViewMutex.Unlock() + fake.RunViewStub = nil + if fake.runViewReturnsOnCall == nil { + fake.runViewReturnsOnCall = make(map[int]struct { + result1 interface{} + result2 error + }) + } + fake.runViewReturnsOnCall[i] = struct { + result1 interface{} + result2 error + }{result1, result2} +} + +func (fake *Context) Session() view.Session { + fake.sessionMutex.Lock() + ret, specificReturn := fake.sessionReturnsOnCall[len(fake.sessionArgsForCall)] + fake.sessionArgsForCall = append(fake.sessionArgsForCall, struct { + }{}) + stub := fake.SessionStub + fakeReturns := fake.sessionReturns + fake.recordInvocation("Session", []interface{}{}) + fake.sessionMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Context) SessionCallCount() int { + fake.sessionMutex.RLock() + defer fake.sessionMutex.RUnlock() + return len(fake.sessionArgsForCall) +} + +func (fake *Context) SessionCalls(stub func() view.Session) { + fake.sessionMutex.Lock() + defer fake.sessionMutex.Unlock() + fake.SessionStub = stub +} + +func (fake *Context) SessionReturns(result1 view.Session) { + fake.sessionMutex.Lock() + defer fake.sessionMutex.Unlock() + fake.SessionStub = nil + fake.sessionReturns = struct { + result1 view.Session + }{result1} +} + +func (fake *Context) SessionReturnsOnCall(i int, result1 view.Session) { + fake.sessionMutex.Lock() + defer fake.sessionMutex.Unlock() + fake.SessionStub = nil + if fake.sessionReturnsOnCall == nil { + fake.sessionReturnsOnCall = make(map[int]struct { + result1 view.Session + }) + } + fake.sessionReturnsOnCall[i] = struct { + result1 view.Session + }{result1} +} + +func (fake *Context) StartSpanFrom(arg1 context.Context, arg2 string, arg3 ...trace.SpanStartOption) (context.Context, trace.Span) { + fake.startSpanFromMutex.Lock() + ret, specificReturn := fake.startSpanFromReturnsOnCall[len(fake.startSpanFromArgsForCall)] + fake.startSpanFromArgsForCall = append(fake.startSpanFromArgsForCall, struct { + arg1 context.Context + arg2 string + arg3 []trace.SpanStartOption + }{arg1, arg2, arg3}) + stub := fake.StartSpanFromStub + fakeReturns := fake.startSpanFromReturns + fake.recordInvocation("StartSpanFrom", []interface{}{arg1, arg2, arg3}) + fake.startSpanFromMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Context) StartSpanFromCallCount() int { + fake.startSpanFromMutex.RLock() + defer fake.startSpanFromMutex.RUnlock() + return len(fake.startSpanFromArgsForCall) +} + +func (fake *Context) StartSpanFromCalls(stub func(context.Context, string, ...trace.SpanStartOption) (context.Context, trace.Span)) { + fake.startSpanFromMutex.Lock() + defer fake.startSpanFromMutex.Unlock() + fake.StartSpanFromStub = stub +} + +func (fake *Context) StartSpanFromArgsForCall(i int) (context.Context, string, []trace.SpanStartOption) { + fake.startSpanFromMutex.RLock() + defer fake.startSpanFromMutex.RUnlock() + argsForCall := fake.startSpanFromArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *Context) StartSpanFromReturns(result1 context.Context, result2 trace.Span) { + fake.startSpanFromMutex.Lock() + defer fake.startSpanFromMutex.Unlock() + fake.StartSpanFromStub = nil + fake.startSpanFromReturns = struct { + result1 context.Context + result2 trace.Span + }{result1, result2} +} + +func (fake *Context) StartSpanFromReturnsOnCall(i int, result1 context.Context, result2 trace.Span) { + fake.startSpanFromMutex.Lock() + defer fake.startSpanFromMutex.Unlock() + fake.StartSpanFromStub = nil + if fake.startSpanFromReturnsOnCall == nil { + fake.startSpanFromReturnsOnCall = make(map[int]struct { + result1 context.Context + result2 trace.Span + }) + } + fake.startSpanFromReturnsOnCall[i] = struct { + result1 context.Context + result2 trace.Span + }{result1, result2} +} + +func (fake *Context) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.contextMutex.RLock() + defer fake.contextMutex.RUnlock() + fake.getServiceMutex.RLock() + defer fake.getServiceMutex.RUnlock() + fake.getSessionMutex.RLock() + defer fake.getSessionMutex.RUnlock() + fake.getSessionByIDMutex.RLock() + defer fake.getSessionByIDMutex.RUnlock() + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + fake.initiatorMutex.RLock() + defer fake.initiatorMutex.RUnlock() + fake.isMeMutex.RLock() + defer fake.isMeMutex.RUnlock() + fake.meMutex.RLock() + defer fake.meMutex.RUnlock() + fake.onErrorMutex.RLock() + defer fake.onErrorMutex.RUnlock() + fake.runViewMutex.RLock() + defer fake.runViewMutex.RUnlock() + fake.sessionMutex.RLock() + defer fake.sessionMutex.RUnlock() + fake.startSpanFromMutex.RLock() + defer fake.startSpanFromMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Context) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fsc.Context = new(Context) diff --git a/token/services/network/fabric/endorsement/fsc/mock/endorser_service.go b/token/services/network/fabric/endorsement/fsc/mock/endorser_service.go new file mode 100644 index 000000000..7827c2671 --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/mock/endorser_service.go @@ -0,0 +1,444 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + "time" + + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/services/endorser" + "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" + "github.com/hyperledger-labs/fabric-token-sdk/token" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" +) + +type EndorserService struct { + CollectEndorsementsStub func(view.Context, *endorser.Transaction, time.Duration, ...view.Identity) error + collectEndorsementsMutex sync.RWMutex + collectEndorsementsArgsForCall []struct { + arg1 view.Context + arg2 *endorser.Transaction + arg3 time.Duration + arg4 []view.Identity + } + collectEndorsementsReturns struct { + result1 error + } + collectEndorsementsReturnsOnCall map[int]struct { + result1 error + } + EndorseStub func(view.Context, *endorser.Transaction, ...view.Identity) (any, error) + endorseMutex sync.RWMutex + endorseArgsForCall []struct { + arg1 view.Context + arg2 *endorser.Transaction + arg3 []view.Identity + } + endorseReturns struct { + result1 any + result2 error + } + endorseReturnsOnCall map[int]struct { + result1 any + result2 error + } + EndorserIDStub func(token.TMSID) (view.Identity, error) + endorserIDMutex sync.RWMutex + endorserIDArgsForCall []struct { + arg1 token.TMSID + } + endorserIDReturns struct { + result1 view.Identity + result2 error + } + endorserIDReturnsOnCall map[int]struct { + result1 view.Identity + result2 error + } + NewTransactionStub func(view.Context, ...fabric.TransactionOption) (*endorser.Transaction, error) + newTransactionMutex sync.RWMutex + newTransactionArgsForCall []struct { + arg1 view.Context + arg2 []fabric.TransactionOption + } + newTransactionReturns struct { + result1 *endorser.Transaction + result2 error + } + newTransactionReturnsOnCall map[int]struct { + result1 *endorser.Transaction + result2 error + } + ReceiveTxStub func(view.Context) (*endorser.Transaction, error) + receiveTxMutex sync.RWMutex + receiveTxArgsForCall []struct { + arg1 view.Context + } + receiveTxReturns struct { + result1 *endorser.Transaction + result2 error + } + receiveTxReturnsOnCall map[int]struct { + result1 *endorser.Transaction + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *EndorserService) CollectEndorsements(arg1 view.Context, arg2 *endorser.Transaction, arg3 time.Duration, arg4 ...view.Identity) error { + fake.collectEndorsementsMutex.Lock() + ret, specificReturn := fake.collectEndorsementsReturnsOnCall[len(fake.collectEndorsementsArgsForCall)] + fake.collectEndorsementsArgsForCall = append(fake.collectEndorsementsArgsForCall, struct { + arg1 view.Context + arg2 *endorser.Transaction + arg3 time.Duration + arg4 []view.Identity + }{arg1, arg2, arg3, arg4}) + stub := fake.CollectEndorsementsStub + fakeReturns := fake.collectEndorsementsReturns + fake.recordInvocation("CollectEndorsements", []interface{}{arg1, arg2, arg3, arg4}) + fake.collectEndorsementsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *EndorserService) CollectEndorsementsCallCount() int { + fake.collectEndorsementsMutex.RLock() + defer fake.collectEndorsementsMutex.RUnlock() + return len(fake.collectEndorsementsArgsForCall) +} + +func (fake *EndorserService) CollectEndorsementsCalls(stub func(view.Context, *endorser.Transaction, time.Duration, ...view.Identity) error) { + fake.collectEndorsementsMutex.Lock() + defer fake.collectEndorsementsMutex.Unlock() + fake.CollectEndorsementsStub = stub +} + +func (fake *EndorserService) CollectEndorsementsArgsForCall(i int) (view.Context, *endorser.Transaction, time.Duration, []view.Identity) { + fake.collectEndorsementsMutex.RLock() + defer fake.collectEndorsementsMutex.RUnlock() + argsForCall := fake.collectEndorsementsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *EndorserService) CollectEndorsementsReturns(result1 error) { + fake.collectEndorsementsMutex.Lock() + defer fake.collectEndorsementsMutex.Unlock() + fake.CollectEndorsementsStub = nil + fake.collectEndorsementsReturns = struct { + result1 error + }{result1} +} + +func (fake *EndorserService) CollectEndorsementsReturnsOnCall(i int, result1 error) { + fake.collectEndorsementsMutex.Lock() + defer fake.collectEndorsementsMutex.Unlock() + fake.CollectEndorsementsStub = nil + if fake.collectEndorsementsReturnsOnCall == nil { + fake.collectEndorsementsReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.collectEndorsementsReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *EndorserService) Endorse(arg1 view.Context, arg2 *endorser.Transaction, arg3 ...view.Identity) (any, error) { + fake.endorseMutex.Lock() + ret, specificReturn := fake.endorseReturnsOnCall[len(fake.endorseArgsForCall)] + fake.endorseArgsForCall = append(fake.endorseArgsForCall, struct { + arg1 view.Context + arg2 *endorser.Transaction + arg3 []view.Identity + }{arg1, arg2, arg3}) + stub := fake.EndorseStub + fakeReturns := fake.endorseReturns + fake.recordInvocation("Endorse", []interface{}{arg1, arg2, arg3}) + fake.endorseMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *EndorserService) EndorseCallCount() int { + fake.endorseMutex.RLock() + defer fake.endorseMutex.RUnlock() + return len(fake.endorseArgsForCall) +} + +func (fake *EndorserService) EndorseCalls(stub func(view.Context, *endorser.Transaction, ...view.Identity) (any, error)) { + fake.endorseMutex.Lock() + defer fake.endorseMutex.Unlock() + fake.EndorseStub = stub +} + +func (fake *EndorserService) EndorseArgsForCall(i int) (view.Context, *endorser.Transaction, []view.Identity) { + fake.endorseMutex.RLock() + defer fake.endorseMutex.RUnlock() + argsForCall := fake.endorseArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *EndorserService) EndorseReturns(result1 any, result2 error) { + fake.endorseMutex.Lock() + defer fake.endorseMutex.Unlock() + fake.EndorseStub = nil + fake.endorseReturns = struct { + result1 any + result2 error + }{result1, result2} +} + +func (fake *EndorserService) EndorseReturnsOnCall(i int, result1 any, result2 error) { + fake.endorseMutex.Lock() + defer fake.endorseMutex.Unlock() + fake.EndorseStub = nil + if fake.endorseReturnsOnCall == nil { + fake.endorseReturnsOnCall = make(map[int]struct { + result1 any + result2 error + }) + } + fake.endorseReturnsOnCall[i] = struct { + result1 any + result2 error + }{result1, result2} +} + +func (fake *EndorserService) EndorserID(arg1 token.TMSID) (view.Identity, error) { + fake.endorserIDMutex.Lock() + ret, specificReturn := fake.endorserIDReturnsOnCall[len(fake.endorserIDArgsForCall)] + fake.endorserIDArgsForCall = append(fake.endorserIDArgsForCall, struct { + arg1 token.TMSID + }{arg1}) + stub := fake.EndorserIDStub + fakeReturns := fake.endorserIDReturns + fake.recordInvocation("EndorserID", []interface{}{arg1}) + fake.endorserIDMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *EndorserService) EndorserIDCallCount() int { + fake.endorserIDMutex.RLock() + defer fake.endorserIDMutex.RUnlock() + return len(fake.endorserIDArgsForCall) +} + +func (fake *EndorserService) EndorserIDCalls(stub func(token.TMSID) (view.Identity, error)) { + fake.endorserIDMutex.Lock() + defer fake.endorserIDMutex.Unlock() + fake.EndorserIDStub = stub +} + +func (fake *EndorserService) EndorserIDArgsForCall(i int) token.TMSID { + fake.endorserIDMutex.RLock() + defer fake.endorserIDMutex.RUnlock() + argsForCall := fake.endorserIDArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *EndorserService) EndorserIDReturns(result1 view.Identity, result2 error) { + fake.endorserIDMutex.Lock() + defer fake.endorserIDMutex.Unlock() + fake.EndorserIDStub = nil + fake.endorserIDReturns = struct { + result1 view.Identity + result2 error + }{result1, result2} +} + +func (fake *EndorserService) EndorserIDReturnsOnCall(i int, result1 view.Identity, result2 error) { + fake.endorserIDMutex.Lock() + defer fake.endorserIDMutex.Unlock() + fake.EndorserIDStub = nil + if fake.endorserIDReturnsOnCall == nil { + fake.endorserIDReturnsOnCall = make(map[int]struct { + result1 view.Identity + result2 error + }) + } + fake.endorserIDReturnsOnCall[i] = struct { + result1 view.Identity + result2 error + }{result1, result2} +} + +func (fake *EndorserService) NewTransaction(arg1 view.Context, arg2 ...fabric.TransactionOption) (*endorser.Transaction, error) { + fake.newTransactionMutex.Lock() + ret, specificReturn := fake.newTransactionReturnsOnCall[len(fake.newTransactionArgsForCall)] + fake.newTransactionArgsForCall = append(fake.newTransactionArgsForCall, struct { + arg1 view.Context + arg2 []fabric.TransactionOption + }{arg1, arg2}) + stub := fake.NewTransactionStub + fakeReturns := fake.newTransactionReturns + fake.recordInvocation("NewTransaction", []interface{}{arg1, arg2}) + fake.newTransactionMutex.Unlock() + if stub != nil { + return stub(arg1, arg2...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *EndorserService) NewTransactionCallCount() int { + fake.newTransactionMutex.RLock() + defer fake.newTransactionMutex.RUnlock() + return len(fake.newTransactionArgsForCall) +} + +func (fake *EndorserService) NewTransactionCalls(stub func(view.Context, ...fabric.TransactionOption) (*endorser.Transaction, error)) { + fake.newTransactionMutex.Lock() + defer fake.newTransactionMutex.Unlock() + fake.NewTransactionStub = stub +} + +func (fake *EndorserService) NewTransactionArgsForCall(i int) (view.Context, []fabric.TransactionOption) { + fake.newTransactionMutex.RLock() + defer fake.newTransactionMutex.RUnlock() + argsForCall := fake.newTransactionArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *EndorserService) NewTransactionReturns(result1 *endorser.Transaction, result2 error) { + fake.newTransactionMutex.Lock() + defer fake.newTransactionMutex.Unlock() + fake.NewTransactionStub = nil + fake.newTransactionReturns = struct { + result1 *endorser.Transaction + result2 error + }{result1, result2} +} + +func (fake *EndorserService) NewTransactionReturnsOnCall(i int, result1 *endorser.Transaction, result2 error) { + fake.newTransactionMutex.Lock() + defer fake.newTransactionMutex.Unlock() + fake.NewTransactionStub = nil + if fake.newTransactionReturnsOnCall == nil { + fake.newTransactionReturnsOnCall = make(map[int]struct { + result1 *endorser.Transaction + result2 error + }) + } + fake.newTransactionReturnsOnCall[i] = struct { + result1 *endorser.Transaction + result2 error + }{result1, result2} +} + +func (fake *EndorserService) ReceiveTx(arg1 view.Context) (*endorser.Transaction, error) { + fake.receiveTxMutex.Lock() + ret, specificReturn := fake.receiveTxReturnsOnCall[len(fake.receiveTxArgsForCall)] + fake.receiveTxArgsForCall = append(fake.receiveTxArgsForCall, struct { + arg1 view.Context + }{arg1}) + stub := fake.ReceiveTxStub + fakeReturns := fake.receiveTxReturns + fake.recordInvocation("ReceiveTx", []interface{}{arg1}) + fake.receiveTxMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *EndorserService) ReceiveTxCallCount() int { + fake.receiveTxMutex.RLock() + defer fake.receiveTxMutex.RUnlock() + return len(fake.receiveTxArgsForCall) +} + +func (fake *EndorserService) ReceiveTxCalls(stub func(view.Context) (*endorser.Transaction, error)) { + fake.receiveTxMutex.Lock() + defer fake.receiveTxMutex.Unlock() + fake.ReceiveTxStub = stub +} + +func (fake *EndorserService) ReceiveTxArgsForCall(i int) view.Context { + fake.receiveTxMutex.RLock() + defer fake.receiveTxMutex.RUnlock() + argsForCall := fake.receiveTxArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *EndorserService) ReceiveTxReturns(result1 *endorser.Transaction, result2 error) { + fake.receiveTxMutex.Lock() + defer fake.receiveTxMutex.Unlock() + fake.ReceiveTxStub = nil + fake.receiveTxReturns = struct { + result1 *endorser.Transaction + result2 error + }{result1, result2} +} + +func (fake *EndorserService) ReceiveTxReturnsOnCall(i int, result1 *endorser.Transaction, result2 error) { + fake.receiveTxMutex.Lock() + defer fake.receiveTxMutex.Unlock() + fake.ReceiveTxStub = nil + if fake.receiveTxReturnsOnCall == nil { + fake.receiveTxReturnsOnCall = make(map[int]struct { + result1 *endorser.Transaction + result2 error + }) + } + fake.receiveTxReturnsOnCall[i] = struct { + result1 *endorser.Transaction + result2 error + }{result1, result2} +} + +func (fake *EndorserService) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.collectEndorsementsMutex.RLock() + defer fake.collectEndorsementsMutex.RUnlock() + fake.endorseMutex.RLock() + defer fake.endorseMutex.RUnlock() + fake.endorserIDMutex.RLock() + defer fake.endorserIDMutex.RUnlock() + fake.newTransactionMutex.RLock() + defer fake.newTransactionMutex.RUnlock() + fake.receiveTxMutex.RLock() + defer fake.receiveTxMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *EndorserService) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fsc.EndorserService = new(EndorserService) diff --git a/token/services/network/fabric/endorsement/fsc/mock/fabric_envelope.go b/token/services/network/fabric/endorsement/fsc/mock/fabric_envelope.go new file mode 100644 index 000000000..b326d6d91 --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/mock/fabric_envelope.go @@ -0,0 +1,511 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" +) + +type Envelope struct { + BytesStub func() ([]byte, error) + bytesMutex sync.RWMutex + bytesArgsForCall []struct { + } + bytesReturns struct { + result1 []byte + result2 error + } + bytesReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + CreatorStub func() []byte + creatorMutex sync.RWMutex + creatorArgsForCall []struct { + } + creatorReturns struct { + result1 []byte + } + creatorReturnsOnCall map[int]struct { + result1 []byte + } + FromBytesStub func([]byte) error + fromBytesMutex sync.RWMutex + fromBytesArgsForCall []struct { + arg1 []byte + } + fromBytesReturns struct { + result1 error + } + fromBytesReturnsOnCall map[int]struct { + result1 error + } + NonceStub func() []byte + nonceMutex sync.RWMutex + nonceArgsForCall []struct { + } + nonceReturns struct { + result1 []byte + } + nonceReturnsOnCall map[int]struct { + result1 []byte + } + ResultsStub func() []byte + resultsMutex sync.RWMutex + resultsArgsForCall []struct { + } + resultsReturns struct { + result1 []byte + } + resultsReturnsOnCall map[int]struct { + result1 []byte + } + StringStub func() string + stringMutex sync.RWMutex + stringArgsForCall []struct { + } + stringReturns struct { + result1 string + } + stringReturnsOnCall map[int]struct { + result1 string + } + TxIDStub func() string + txIDMutex sync.RWMutex + txIDArgsForCall []struct { + } + txIDReturns struct { + result1 string + } + txIDReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Envelope) Bytes() ([]byte, error) { + fake.bytesMutex.Lock() + ret, specificReturn := fake.bytesReturnsOnCall[len(fake.bytesArgsForCall)] + fake.bytesArgsForCall = append(fake.bytesArgsForCall, struct { + }{}) + stub := fake.BytesStub + fakeReturns := fake.bytesReturns + fake.recordInvocation("Bytes", []interface{}{}) + fake.bytesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Envelope) BytesCallCount() int { + fake.bytesMutex.RLock() + defer fake.bytesMutex.RUnlock() + return len(fake.bytesArgsForCall) +} + +func (fake *Envelope) BytesCalls(stub func() ([]byte, error)) { + fake.bytesMutex.Lock() + defer fake.bytesMutex.Unlock() + fake.BytesStub = stub +} + +func (fake *Envelope) BytesReturns(result1 []byte, result2 error) { + fake.bytesMutex.Lock() + defer fake.bytesMutex.Unlock() + fake.BytesStub = nil + fake.bytesReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *Envelope) BytesReturnsOnCall(i int, result1 []byte, result2 error) { + fake.bytesMutex.Lock() + defer fake.bytesMutex.Unlock() + fake.BytesStub = nil + if fake.bytesReturnsOnCall == nil { + fake.bytesReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.bytesReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *Envelope) Creator() []byte { + fake.creatorMutex.Lock() + ret, specificReturn := fake.creatorReturnsOnCall[len(fake.creatorArgsForCall)] + fake.creatorArgsForCall = append(fake.creatorArgsForCall, struct { + }{}) + stub := fake.CreatorStub + fakeReturns := fake.creatorReturns + fake.recordInvocation("Creator", []interface{}{}) + fake.creatorMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Envelope) CreatorCallCount() int { + fake.creatorMutex.RLock() + defer fake.creatorMutex.RUnlock() + return len(fake.creatorArgsForCall) +} + +func (fake *Envelope) CreatorCalls(stub func() []byte) { + fake.creatorMutex.Lock() + defer fake.creatorMutex.Unlock() + fake.CreatorStub = stub +} + +func (fake *Envelope) CreatorReturns(result1 []byte) { + fake.creatorMutex.Lock() + defer fake.creatorMutex.Unlock() + fake.CreatorStub = nil + fake.creatorReturns = struct { + result1 []byte + }{result1} +} + +func (fake *Envelope) CreatorReturnsOnCall(i int, result1 []byte) { + fake.creatorMutex.Lock() + defer fake.creatorMutex.Unlock() + fake.CreatorStub = nil + if fake.creatorReturnsOnCall == nil { + fake.creatorReturnsOnCall = make(map[int]struct { + result1 []byte + }) + } + fake.creatorReturnsOnCall[i] = struct { + result1 []byte + }{result1} +} + +func (fake *Envelope) FromBytes(arg1 []byte) error { + var arg1Copy []byte + if arg1 != nil { + arg1Copy = make([]byte, len(arg1)) + copy(arg1Copy, arg1) + } + fake.fromBytesMutex.Lock() + ret, specificReturn := fake.fromBytesReturnsOnCall[len(fake.fromBytesArgsForCall)] + fake.fromBytesArgsForCall = append(fake.fromBytesArgsForCall, struct { + arg1 []byte + }{arg1Copy}) + stub := fake.FromBytesStub + fakeReturns := fake.fromBytesReturns + fake.recordInvocation("FromBytes", []interface{}{arg1Copy}) + fake.fromBytesMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Envelope) FromBytesCallCount() int { + fake.fromBytesMutex.RLock() + defer fake.fromBytesMutex.RUnlock() + return len(fake.fromBytesArgsForCall) +} + +func (fake *Envelope) FromBytesCalls(stub func([]byte) error) { + fake.fromBytesMutex.Lock() + defer fake.fromBytesMutex.Unlock() + fake.FromBytesStub = stub +} + +func (fake *Envelope) FromBytesArgsForCall(i int) []byte { + fake.fromBytesMutex.RLock() + defer fake.fromBytesMutex.RUnlock() + argsForCall := fake.fromBytesArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *Envelope) FromBytesReturns(result1 error) { + fake.fromBytesMutex.Lock() + defer fake.fromBytesMutex.Unlock() + fake.FromBytesStub = nil + fake.fromBytesReturns = struct { + result1 error + }{result1} +} + +func (fake *Envelope) FromBytesReturnsOnCall(i int, result1 error) { + fake.fromBytesMutex.Lock() + defer fake.fromBytesMutex.Unlock() + fake.FromBytesStub = nil + if fake.fromBytesReturnsOnCall == nil { + fake.fromBytesReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.fromBytesReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Envelope) Nonce() []byte { + fake.nonceMutex.Lock() + ret, specificReturn := fake.nonceReturnsOnCall[len(fake.nonceArgsForCall)] + fake.nonceArgsForCall = append(fake.nonceArgsForCall, struct { + }{}) + stub := fake.NonceStub + fakeReturns := fake.nonceReturns + fake.recordInvocation("Nonce", []interface{}{}) + fake.nonceMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Envelope) NonceCallCount() int { + fake.nonceMutex.RLock() + defer fake.nonceMutex.RUnlock() + return len(fake.nonceArgsForCall) +} + +func (fake *Envelope) NonceCalls(stub func() []byte) { + fake.nonceMutex.Lock() + defer fake.nonceMutex.Unlock() + fake.NonceStub = stub +} + +func (fake *Envelope) NonceReturns(result1 []byte) { + fake.nonceMutex.Lock() + defer fake.nonceMutex.Unlock() + fake.NonceStub = nil + fake.nonceReturns = struct { + result1 []byte + }{result1} +} + +func (fake *Envelope) NonceReturnsOnCall(i int, result1 []byte) { + fake.nonceMutex.Lock() + defer fake.nonceMutex.Unlock() + fake.NonceStub = nil + if fake.nonceReturnsOnCall == nil { + fake.nonceReturnsOnCall = make(map[int]struct { + result1 []byte + }) + } + fake.nonceReturnsOnCall[i] = struct { + result1 []byte + }{result1} +} + +func (fake *Envelope) Results() []byte { + fake.resultsMutex.Lock() + ret, specificReturn := fake.resultsReturnsOnCall[len(fake.resultsArgsForCall)] + fake.resultsArgsForCall = append(fake.resultsArgsForCall, struct { + }{}) + stub := fake.ResultsStub + fakeReturns := fake.resultsReturns + fake.recordInvocation("Results", []interface{}{}) + fake.resultsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Envelope) ResultsCallCount() int { + fake.resultsMutex.RLock() + defer fake.resultsMutex.RUnlock() + return len(fake.resultsArgsForCall) +} + +func (fake *Envelope) ResultsCalls(stub func() []byte) { + fake.resultsMutex.Lock() + defer fake.resultsMutex.Unlock() + fake.ResultsStub = stub +} + +func (fake *Envelope) ResultsReturns(result1 []byte) { + fake.resultsMutex.Lock() + defer fake.resultsMutex.Unlock() + fake.ResultsStub = nil + fake.resultsReturns = struct { + result1 []byte + }{result1} +} + +func (fake *Envelope) ResultsReturnsOnCall(i int, result1 []byte) { + fake.resultsMutex.Lock() + defer fake.resultsMutex.Unlock() + fake.ResultsStub = nil + if fake.resultsReturnsOnCall == nil { + fake.resultsReturnsOnCall = make(map[int]struct { + result1 []byte + }) + } + fake.resultsReturnsOnCall[i] = struct { + result1 []byte + }{result1} +} + +func (fake *Envelope) String() string { + fake.stringMutex.Lock() + ret, specificReturn := fake.stringReturnsOnCall[len(fake.stringArgsForCall)] + fake.stringArgsForCall = append(fake.stringArgsForCall, struct { + }{}) + stub := fake.StringStub + fakeReturns := fake.stringReturns + fake.recordInvocation("String", []interface{}{}) + fake.stringMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Envelope) StringCallCount() int { + fake.stringMutex.RLock() + defer fake.stringMutex.RUnlock() + return len(fake.stringArgsForCall) +} + +func (fake *Envelope) StringCalls(stub func() string) { + fake.stringMutex.Lock() + defer fake.stringMutex.Unlock() + fake.StringStub = stub +} + +func (fake *Envelope) StringReturns(result1 string) { + fake.stringMutex.Lock() + defer fake.stringMutex.Unlock() + fake.StringStub = nil + fake.stringReturns = struct { + result1 string + }{result1} +} + +func (fake *Envelope) StringReturnsOnCall(i int, result1 string) { + fake.stringMutex.Lock() + defer fake.stringMutex.Unlock() + fake.StringStub = nil + if fake.stringReturnsOnCall == nil { + fake.stringReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.stringReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *Envelope) TxID() string { + fake.txIDMutex.Lock() + ret, specificReturn := fake.txIDReturnsOnCall[len(fake.txIDArgsForCall)] + fake.txIDArgsForCall = append(fake.txIDArgsForCall, struct { + }{}) + stub := fake.TxIDStub + fakeReturns := fake.txIDReturns + fake.recordInvocation("TxID", []interface{}{}) + fake.txIDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Envelope) TxIDCallCount() int { + fake.txIDMutex.RLock() + defer fake.txIDMutex.RUnlock() + return len(fake.txIDArgsForCall) +} + +func (fake *Envelope) TxIDCalls(stub func() string) { + fake.txIDMutex.Lock() + defer fake.txIDMutex.Unlock() + fake.TxIDStub = stub +} + +func (fake *Envelope) TxIDReturns(result1 string) { + fake.txIDMutex.Lock() + defer fake.txIDMutex.Unlock() + fake.TxIDStub = nil + fake.txIDReturns = struct { + result1 string + }{result1} +} + +func (fake *Envelope) TxIDReturnsOnCall(i int, result1 string) { + fake.txIDMutex.Lock() + defer fake.txIDMutex.Unlock() + fake.TxIDStub = nil + if fake.txIDReturnsOnCall == nil { + fake.txIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.txIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *Envelope) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.bytesMutex.RLock() + defer fake.bytesMutex.RUnlock() + fake.creatorMutex.RLock() + defer fake.creatorMutex.RUnlock() + fake.fromBytesMutex.RLock() + defer fake.fromBytesMutex.RUnlock() + fake.nonceMutex.RLock() + defer fake.nonceMutex.RUnlock() + fake.resultsMutex.RLock() + defer fake.resultsMutex.RUnlock() + fake.stringMutex.RLock() + defer fake.stringMutex.RUnlock() + fake.txIDMutex.RLock() + defer fake.txIDMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Envelope) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fsc.Envelope = new(Envelope) diff --git a/token/services/network/fabric/endorsement/fsc/mock/fabric_rws.go b/token/services/network/fabric/endorsement/fsc/mock/fabric_rws.go new file mode 100644 index 000000000..ccd2215f7 --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/mock/fabric_rws.go @@ -0,0 +1,1522 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + + "github.com/hyperledger-labs/fabric-smart-client/platform/common/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" +) + +type FabricRWSet struct { + AddReadAtStub func(driver.Namespace, string, driver.RawVersion) error + addReadAtMutex sync.RWMutex + addReadAtArgsForCall []struct { + arg1 driver.Namespace + arg2 string + arg3 driver.RawVersion + } + addReadAtReturns struct { + result1 error + } + addReadAtReturnsOnCall map[int]struct { + result1 error + } + AppendRWSetStub func([]byte, ...driver.Namespace) error + appendRWSetMutex sync.RWMutex + appendRWSetArgsForCall []struct { + arg1 []byte + arg2 []driver.Namespace + } + appendRWSetReturns struct { + result1 error + } + appendRWSetReturnsOnCall map[int]struct { + result1 error + } + BytesStub func() ([]byte, error) + bytesMutex sync.RWMutex + bytesArgsForCall []struct { + } + bytesReturns struct { + result1 []byte + result2 error + } + bytesReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + ClearStub func(driver.Namespace) error + clearMutex sync.RWMutex + clearArgsForCall []struct { + arg1 driver.Namespace + } + clearReturns struct { + result1 error + } + clearReturnsOnCall map[int]struct { + result1 error + } + DeleteStateStub func(driver.Namespace, driver.PKey) error + deleteStateMutex sync.RWMutex + deleteStateArgsForCall []struct { + arg1 driver.Namespace + arg2 driver.PKey + } + deleteStateReturns struct { + result1 error + } + deleteStateReturnsOnCall map[int]struct { + result1 error + } + DoneStub func() + doneMutex sync.RWMutex + doneArgsForCall []struct { + } + EqualsStub func(interface{}, ...driver.Namespace) error + equalsMutex sync.RWMutex + equalsArgsForCall []struct { + arg1 interface{} + arg2 []driver.Namespace + } + equalsReturns struct { + result1 error + } + equalsReturnsOnCall map[int]struct { + result1 error + } + GetDirectStateStub func(driver.Namespace, driver.PKey) (driver.RawValue, error) + getDirectStateMutex sync.RWMutex + getDirectStateArgsForCall []struct { + arg1 driver.Namespace + arg2 driver.PKey + } + getDirectStateReturns struct { + result1 driver.RawValue + result2 error + } + getDirectStateReturnsOnCall map[int]struct { + result1 driver.RawValue + result2 error + } + GetReadAtStub func(driver.Namespace, int) (driver.PKey, driver.RawValue, error) + getReadAtMutex sync.RWMutex + getReadAtArgsForCall []struct { + arg1 driver.Namespace + arg2 int + } + getReadAtReturns struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + } + getReadAtReturnsOnCall map[int]struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + } + GetReadKeyAtStub func(driver.Namespace, int) (driver.PKey, error) + getReadKeyAtMutex sync.RWMutex + getReadKeyAtArgsForCall []struct { + arg1 driver.Namespace + arg2 int + } + getReadKeyAtReturns struct { + result1 driver.PKey + result2 error + } + getReadKeyAtReturnsOnCall map[int]struct { + result1 driver.PKey + result2 error + } + GetStateStub func(driver.Namespace, driver.PKey, ...driver.GetStateOpt) (driver.RawValue, error) + getStateMutex sync.RWMutex + getStateArgsForCall []struct { + arg1 driver.Namespace + arg2 driver.PKey + arg3 []driver.GetStateOpt + } + getStateReturns struct { + result1 driver.RawValue + result2 error + } + getStateReturnsOnCall map[int]struct { + result1 driver.RawValue + result2 error + } + GetStateMetadataStub func(driver.Namespace, driver.PKey, ...driver.GetStateOpt) (driver.Metadata, error) + getStateMetadataMutex sync.RWMutex + getStateMetadataArgsForCall []struct { + arg1 driver.Namespace + arg2 driver.PKey + arg3 []driver.GetStateOpt + } + getStateMetadataReturns struct { + result1 driver.Metadata + result2 error + } + getStateMetadataReturnsOnCall map[int]struct { + result1 driver.Metadata + result2 error + } + GetWriteAtStub func(driver.Namespace, int) (driver.PKey, driver.RawValue, error) + getWriteAtMutex sync.RWMutex + getWriteAtArgsForCall []struct { + arg1 driver.Namespace + arg2 int + } + getWriteAtReturns struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + } + getWriteAtReturnsOnCall map[int]struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + } + IsClosedStub func() bool + isClosedMutex sync.RWMutex + isClosedArgsForCall []struct { + } + isClosedReturns struct { + result1 bool + } + isClosedReturnsOnCall map[int]struct { + result1 bool + } + IsValidStub func() error + isValidMutex sync.RWMutex + isValidArgsForCall []struct { + } + isValidReturns struct { + result1 error + } + isValidReturnsOnCall map[int]struct { + result1 error + } + NamespacesStub func() []driver.Namespace + namespacesMutex sync.RWMutex + namespacesArgsForCall []struct { + } + namespacesReturns struct { + result1 []driver.Namespace + } + namespacesReturnsOnCall map[int]struct { + result1 []driver.Namespace + } + NumReadsStub func(driver.Namespace) int + numReadsMutex sync.RWMutex + numReadsArgsForCall []struct { + arg1 driver.Namespace + } + numReadsReturns struct { + result1 int + } + numReadsReturnsOnCall map[int]struct { + result1 int + } + NumWritesStub func(driver.Namespace) int + numWritesMutex sync.RWMutex + numWritesArgsForCall []struct { + arg1 driver.Namespace + } + numWritesReturns struct { + result1 int + } + numWritesReturnsOnCall map[int]struct { + result1 int + } + SetStateStub func(driver.Namespace, driver.PKey, driver.RawValue) error + setStateMutex sync.RWMutex + setStateArgsForCall []struct { + arg1 driver.Namespace + arg2 driver.PKey + arg3 driver.RawValue + } + setStateReturns struct { + result1 error + } + setStateReturnsOnCall map[int]struct { + result1 error + } + SetStateMetadataStub func(driver.Namespace, driver.PKey, driver.Metadata) error + setStateMetadataMutex sync.RWMutex + setStateMetadataArgsForCall []struct { + arg1 driver.Namespace + arg2 driver.PKey + arg3 driver.Metadata + } + setStateMetadataReturns struct { + result1 error + } + setStateMetadataReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FabricRWSet) AddReadAt(arg1 driver.Namespace, arg2 string, arg3 driver.RawVersion) error { + fake.addReadAtMutex.Lock() + ret, specificReturn := fake.addReadAtReturnsOnCall[len(fake.addReadAtArgsForCall)] + fake.addReadAtArgsForCall = append(fake.addReadAtArgsForCall, struct { + arg1 driver.Namespace + arg2 string + arg3 driver.RawVersion + }{arg1, arg2, arg3}) + stub := fake.AddReadAtStub + fakeReturns := fake.addReadAtReturns + fake.recordInvocation("AddReadAt", []interface{}{arg1, arg2, arg3}) + fake.addReadAtMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) AddReadAtCallCount() int { + fake.addReadAtMutex.RLock() + defer fake.addReadAtMutex.RUnlock() + return len(fake.addReadAtArgsForCall) +} + +func (fake *FabricRWSet) AddReadAtCalls(stub func(driver.Namespace, string, driver.RawVersion) error) { + fake.addReadAtMutex.Lock() + defer fake.addReadAtMutex.Unlock() + fake.AddReadAtStub = stub +} + +func (fake *FabricRWSet) AddReadAtArgsForCall(i int) (driver.Namespace, string, driver.RawVersion) { + fake.addReadAtMutex.RLock() + defer fake.addReadAtMutex.RUnlock() + argsForCall := fake.addReadAtArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FabricRWSet) AddReadAtReturns(result1 error) { + fake.addReadAtMutex.Lock() + defer fake.addReadAtMutex.Unlock() + fake.AddReadAtStub = nil + fake.addReadAtReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) AddReadAtReturnsOnCall(i int, result1 error) { + fake.addReadAtMutex.Lock() + defer fake.addReadAtMutex.Unlock() + fake.AddReadAtStub = nil + if fake.addReadAtReturnsOnCall == nil { + fake.addReadAtReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.addReadAtReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) AppendRWSet(arg1 []byte, arg2 ...driver.Namespace) error { + var arg1Copy []byte + if arg1 != nil { + arg1Copy = make([]byte, len(arg1)) + copy(arg1Copy, arg1) + } + fake.appendRWSetMutex.Lock() + ret, specificReturn := fake.appendRWSetReturnsOnCall[len(fake.appendRWSetArgsForCall)] + fake.appendRWSetArgsForCall = append(fake.appendRWSetArgsForCall, struct { + arg1 []byte + arg2 []driver.Namespace + }{arg1Copy, arg2}) + stub := fake.AppendRWSetStub + fakeReturns := fake.appendRWSetReturns + fake.recordInvocation("AppendRWSet", []interface{}{arg1Copy, arg2}) + fake.appendRWSetMutex.Unlock() + if stub != nil { + return stub(arg1, arg2...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) AppendRWSetCallCount() int { + fake.appendRWSetMutex.RLock() + defer fake.appendRWSetMutex.RUnlock() + return len(fake.appendRWSetArgsForCall) +} + +func (fake *FabricRWSet) AppendRWSetCalls(stub func([]byte, ...driver.Namespace) error) { + fake.appendRWSetMutex.Lock() + defer fake.appendRWSetMutex.Unlock() + fake.AppendRWSetStub = stub +} + +func (fake *FabricRWSet) AppendRWSetArgsForCall(i int) ([]byte, []driver.Namespace) { + fake.appendRWSetMutex.RLock() + defer fake.appendRWSetMutex.RUnlock() + argsForCall := fake.appendRWSetArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FabricRWSet) AppendRWSetReturns(result1 error) { + fake.appendRWSetMutex.Lock() + defer fake.appendRWSetMutex.Unlock() + fake.AppendRWSetStub = nil + fake.appendRWSetReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) AppendRWSetReturnsOnCall(i int, result1 error) { + fake.appendRWSetMutex.Lock() + defer fake.appendRWSetMutex.Unlock() + fake.AppendRWSetStub = nil + if fake.appendRWSetReturnsOnCall == nil { + fake.appendRWSetReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.appendRWSetReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) Bytes() ([]byte, error) { + fake.bytesMutex.Lock() + ret, specificReturn := fake.bytesReturnsOnCall[len(fake.bytesArgsForCall)] + fake.bytesArgsForCall = append(fake.bytesArgsForCall, struct { + }{}) + stub := fake.BytesStub + fakeReturns := fake.bytesReturns + fake.recordInvocation("Bytes", []interface{}{}) + fake.bytesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricRWSet) BytesCallCount() int { + fake.bytesMutex.RLock() + defer fake.bytesMutex.RUnlock() + return len(fake.bytesArgsForCall) +} + +func (fake *FabricRWSet) BytesCalls(stub func() ([]byte, error)) { + fake.bytesMutex.Lock() + defer fake.bytesMutex.Unlock() + fake.BytesStub = stub +} + +func (fake *FabricRWSet) BytesReturns(result1 []byte, result2 error) { + fake.bytesMutex.Lock() + defer fake.bytesMutex.Unlock() + fake.BytesStub = nil + fake.bytesReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) BytesReturnsOnCall(i int, result1 []byte, result2 error) { + fake.bytesMutex.Lock() + defer fake.bytesMutex.Unlock() + fake.BytesStub = nil + if fake.bytesReturnsOnCall == nil { + fake.bytesReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.bytesReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) Clear(arg1 driver.Namespace) error { + fake.clearMutex.Lock() + ret, specificReturn := fake.clearReturnsOnCall[len(fake.clearArgsForCall)] + fake.clearArgsForCall = append(fake.clearArgsForCall, struct { + arg1 driver.Namespace + }{arg1}) + stub := fake.ClearStub + fakeReturns := fake.clearReturns + fake.recordInvocation("Clear", []interface{}{arg1}) + fake.clearMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) ClearCallCount() int { + fake.clearMutex.RLock() + defer fake.clearMutex.RUnlock() + return len(fake.clearArgsForCall) +} + +func (fake *FabricRWSet) ClearCalls(stub func(driver.Namespace) error) { + fake.clearMutex.Lock() + defer fake.clearMutex.Unlock() + fake.ClearStub = stub +} + +func (fake *FabricRWSet) ClearArgsForCall(i int) driver.Namespace { + fake.clearMutex.RLock() + defer fake.clearMutex.RUnlock() + argsForCall := fake.clearArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricRWSet) ClearReturns(result1 error) { + fake.clearMutex.Lock() + defer fake.clearMutex.Unlock() + fake.ClearStub = nil + fake.clearReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) ClearReturnsOnCall(i int, result1 error) { + fake.clearMutex.Lock() + defer fake.clearMutex.Unlock() + fake.ClearStub = nil + if fake.clearReturnsOnCall == nil { + fake.clearReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.clearReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) DeleteState(arg1 driver.Namespace, arg2 driver.PKey) error { + fake.deleteStateMutex.Lock() + ret, specificReturn := fake.deleteStateReturnsOnCall[len(fake.deleteStateArgsForCall)] + fake.deleteStateArgsForCall = append(fake.deleteStateArgsForCall, struct { + arg1 driver.Namespace + arg2 driver.PKey + }{arg1, arg2}) + stub := fake.DeleteStateStub + fakeReturns := fake.deleteStateReturns + fake.recordInvocation("DeleteState", []interface{}{arg1, arg2}) + fake.deleteStateMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) DeleteStateCallCount() int { + fake.deleteStateMutex.RLock() + defer fake.deleteStateMutex.RUnlock() + return len(fake.deleteStateArgsForCall) +} + +func (fake *FabricRWSet) DeleteStateCalls(stub func(driver.Namespace, driver.PKey) error) { + fake.deleteStateMutex.Lock() + defer fake.deleteStateMutex.Unlock() + fake.DeleteStateStub = stub +} + +func (fake *FabricRWSet) DeleteStateArgsForCall(i int) (driver.Namespace, driver.PKey) { + fake.deleteStateMutex.RLock() + defer fake.deleteStateMutex.RUnlock() + argsForCall := fake.deleteStateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FabricRWSet) DeleteStateReturns(result1 error) { + fake.deleteStateMutex.Lock() + defer fake.deleteStateMutex.Unlock() + fake.DeleteStateStub = nil + fake.deleteStateReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) DeleteStateReturnsOnCall(i int, result1 error) { + fake.deleteStateMutex.Lock() + defer fake.deleteStateMutex.Unlock() + fake.DeleteStateStub = nil + if fake.deleteStateReturnsOnCall == nil { + fake.deleteStateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteStateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) Done() { + fake.doneMutex.Lock() + fake.doneArgsForCall = append(fake.doneArgsForCall, struct { + }{}) + stub := fake.DoneStub + fake.recordInvocation("Done", []interface{}{}) + fake.doneMutex.Unlock() + if stub != nil { + fake.DoneStub() + } +} + +func (fake *FabricRWSet) DoneCallCount() int { + fake.doneMutex.RLock() + defer fake.doneMutex.RUnlock() + return len(fake.doneArgsForCall) +} + +func (fake *FabricRWSet) DoneCalls(stub func()) { + fake.doneMutex.Lock() + defer fake.doneMutex.Unlock() + fake.DoneStub = stub +} + +func (fake *FabricRWSet) Equals(arg1 interface{}, arg2 ...driver.Namespace) error { + fake.equalsMutex.Lock() + ret, specificReturn := fake.equalsReturnsOnCall[len(fake.equalsArgsForCall)] + fake.equalsArgsForCall = append(fake.equalsArgsForCall, struct { + arg1 interface{} + arg2 []driver.Namespace + }{arg1, arg2}) + stub := fake.EqualsStub + fakeReturns := fake.equalsReturns + fake.recordInvocation("Equals", []interface{}{arg1, arg2}) + fake.equalsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) EqualsCallCount() int { + fake.equalsMutex.RLock() + defer fake.equalsMutex.RUnlock() + return len(fake.equalsArgsForCall) +} + +func (fake *FabricRWSet) EqualsCalls(stub func(interface{}, ...driver.Namespace) error) { + fake.equalsMutex.Lock() + defer fake.equalsMutex.Unlock() + fake.EqualsStub = stub +} + +func (fake *FabricRWSet) EqualsArgsForCall(i int) (interface{}, []driver.Namespace) { + fake.equalsMutex.RLock() + defer fake.equalsMutex.RUnlock() + argsForCall := fake.equalsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FabricRWSet) EqualsReturns(result1 error) { + fake.equalsMutex.Lock() + defer fake.equalsMutex.Unlock() + fake.EqualsStub = nil + fake.equalsReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) EqualsReturnsOnCall(i int, result1 error) { + fake.equalsMutex.Lock() + defer fake.equalsMutex.Unlock() + fake.EqualsStub = nil + if fake.equalsReturnsOnCall == nil { + fake.equalsReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.equalsReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) GetDirectState(arg1 driver.Namespace, arg2 driver.PKey) (driver.RawValue, error) { + fake.getDirectStateMutex.Lock() + ret, specificReturn := fake.getDirectStateReturnsOnCall[len(fake.getDirectStateArgsForCall)] + fake.getDirectStateArgsForCall = append(fake.getDirectStateArgsForCall, struct { + arg1 driver.Namespace + arg2 driver.PKey + }{arg1, arg2}) + stub := fake.GetDirectStateStub + fakeReturns := fake.getDirectStateReturns + fake.recordInvocation("GetDirectState", []interface{}{arg1, arg2}) + fake.getDirectStateMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricRWSet) GetDirectStateCallCount() int { + fake.getDirectStateMutex.RLock() + defer fake.getDirectStateMutex.RUnlock() + return len(fake.getDirectStateArgsForCall) +} + +func (fake *FabricRWSet) GetDirectStateCalls(stub func(driver.Namespace, driver.PKey) (driver.RawValue, error)) { + fake.getDirectStateMutex.Lock() + defer fake.getDirectStateMutex.Unlock() + fake.GetDirectStateStub = stub +} + +func (fake *FabricRWSet) GetDirectStateArgsForCall(i int) (driver.Namespace, driver.PKey) { + fake.getDirectStateMutex.RLock() + defer fake.getDirectStateMutex.RUnlock() + argsForCall := fake.getDirectStateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FabricRWSet) GetDirectStateReturns(result1 driver.RawValue, result2 error) { + fake.getDirectStateMutex.Lock() + defer fake.getDirectStateMutex.Unlock() + fake.GetDirectStateStub = nil + fake.getDirectStateReturns = struct { + result1 driver.RawValue + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) GetDirectStateReturnsOnCall(i int, result1 driver.RawValue, result2 error) { + fake.getDirectStateMutex.Lock() + defer fake.getDirectStateMutex.Unlock() + fake.GetDirectStateStub = nil + if fake.getDirectStateReturnsOnCall == nil { + fake.getDirectStateReturnsOnCall = make(map[int]struct { + result1 driver.RawValue + result2 error + }) + } + fake.getDirectStateReturnsOnCall[i] = struct { + result1 driver.RawValue + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) GetReadAt(arg1 driver.Namespace, arg2 int) (driver.PKey, driver.RawValue, error) { + fake.getReadAtMutex.Lock() + ret, specificReturn := fake.getReadAtReturnsOnCall[len(fake.getReadAtArgsForCall)] + fake.getReadAtArgsForCall = append(fake.getReadAtArgsForCall, struct { + arg1 driver.Namespace + arg2 int + }{arg1, arg2}) + stub := fake.GetReadAtStub + fakeReturns := fake.getReadAtReturns + fake.recordInvocation("GetReadAt", []interface{}{arg1, arg2}) + fake.getReadAtMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FabricRWSet) GetReadAtCallCount() int { + fake.getReadAtMutex.RLock() + defer fake.getReadAtMutex.RUnlock() + return len(fake.getReadAtArgsForCall) +} + +func (fake *FabricRWSet) GetReadAtCalls(stub func(driver.Namespace, int) (driver.PKey, driver.RawValue, error)) { + fake.getReadAtMutex.Lock() + defer fake.getReadAtMutex.Unlock() + fake.GetReadAtStub = stub +} + +func (fake *FabricRWSet) GetReadAtArgsForCall(i int) (driver.Namespace, int) { + fake.getReadAtMutex.RLock() + defer fake.getReadAtMutex.RUnlock() + argsForCall := fake.getReadAtArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FabricRWSet) GetReadAtReturns(result1 driver.PKey, result2 driver.RawValue, result3 error) { + fake.getReadAtMutex.Lock() + defer fake.getReadAtMutex.Unlock() + fake.GetReadAtStub = nil + fake.getReadAtReturns = struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + }{result1, result2, result3} +} + +func (fake *FabricRWSet) GetReadAtReturnsOnCall(i int, result1 driver.PKey, result2 driver.RawValue, result3 error) { + fake.getReadAtMutex.Lock() + defer fake.getReadAtMutex.Unlock() + fake.GetReadAtStub = nil + if fake.getReadAtReturnsOnCall == nil { + fake.getReadAtReturnsOnCall = make(map[int]struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + }) + } + fake.getReadAtReturnsOnCall[i] = struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + }{result1, result2, result3} +} + +func (fake *FabricRWSet) GetReadKeyAt(arg1 driver.Namespace, arg2 int) (driver.PKey, error) { + fake.getReadKeyAtMutex.Lock() + ret, specificReturn := fake.getReadKeyAtReturnsOnCall[len(fake.getReadKeyAtArgsForCall)] + fake.getReadKeyAtArgsForCall = append(fake.getReadKeyAtArgsForCall, struct { + arg1 driver.Namespace + arg2 int + }{arg1, arg2}) + stub := fake.GetReadKeyAtStub + fakeReturns := fake.getReadKeyAtReturns + fake.recordInvocation("GetReadKeyAt", []interface{}{arg1, arg2}) + fake.getReadKeyAtMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricRWSet) GetReadKeyAtCallCount() int { + fake.getReadKeyAtMutex.RLock() + defer fake.getReadKeyAtMutex.RUnlock() + return len(fake.getReadKeyAtArgsForCall) +} + +func (fake *FabricRWSet) GetReadKeyAtCalls(stub func(driver.Namespace, int) (driver.PKey, error)) { + fake.getReadKeyAtMutex.Lock() + defer fake.getReadKeyAtMutex.Unlock() + fake.GetReadKeyAtStub = stub +} + +func (fake *FabricRWSet) GetReadKeyAtArgsForCall(i int) (driver.Namespace, int) { + fake.getReadKeyAtMutex.RLock() + defer fake.getReadKeyAtMutex.RUnlock() + argsForCall := fake.getReadKeyAtArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FabricRWSet) GetReadKeyAtReturns(result1 driver.PKey, result2 error) { + fake.getReadKeyAtMutex.Lock() + defer fake.getReadKeyAtMutex.Unlock() + fake.GetReadKeyAtStub = nil + fake.getReadKeyAtReturns = struct { + result1 driver.PKey + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) GetReadKeyAtReturnsOnCall(i int, result1 driver.PKey, result2 error) { + fake.getReadKeyAtMutex.Lock() + defer fake.getReadKeyAtMutex.Unlock() + fake.GetReadKeyAtStub = nil + if fake.getReadKeyAtReturnsOnCall == nil { + fake.getReadKeyAtReturnsOnCall = make(map[int]struct { + result1 driver.PKey + result2 error + }) + } + fake.getReadKeyAtReturnsOnCall[i] = struct { + result1 driver.PKey + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) GetState(arg1 driver.Namespace, arg2 driver.PKey, arg3 ...driver.GetStateOpt) (driver.RawValue, error) { + fake.getStateMutex.Lock() + ret, specificReturn := fake.getStateReturnsOnCall[len(fake.getStateArgsForCall)] + fake.getStateArgsForCall = append(fake.getStateArgsForCall, struct { + arg1 driver.Namespace + arg2 driver.PKey + arg3 []driver.GetStateOpt + }{arg1, arg2, arg3}) + stub := fake.GetStateStub + fakeReturns := fake.getStateReturns + fake.recordInvocation("GetState", []interface{}{arg1, arg2, arg3}) + fake.getStateMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricRWSet) GetStateCallCount() int { + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + return len(fake.getStateArgsForCall) +} + +func (fake *FabricRWSet) GetStateCalls(stub func(driver.Namespace, driver.PKey, ...driver.GetStateOpt) (driver.RawValue, error)) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = stub +} + +func (fake *FabricRWSet) GetStateArgsForCall(i int) (driver.Namespace, driver.PKey, []driver.GetStateOpt) { + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + argsForCall := fake.getStateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FabricRWSet) GetStateReturns(result1 driver.RawValue, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + fake.getStateReturns = struct { + result1 driver.RawValue + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) GetStateReturnsOnCall(i int, result1 driver.RawValue, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + if fake.getStateReturnsOnCall == nil { + fake.getStateReturnsOnCall = make(map[int]struct { + result1 driver.RawValue + result2 error + }) + } + fake.getStateReturnsOnCall[i] = struct { + result1 driver.RawValue + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) GetStateMetadata(arg1 driver.Namespace, arg2 driver.PKey, arg3 ...driver.GetStateOpt) (driver.Metadata, error) { + fake.getStateMetadataMutex.Lock() + ret, specificReturn := fake.getStateMetadataReturnsOnCall[len(fake.getStateMetadataArgsForCall)] + fake.getStateMetadataArgsForCall = append(fake.getStateMetadataArgsForCall, struct { + arg1 driver.Namespace + arg2 driver.PKey + arg3 []driver.GetStateOpt + }{arg1, arg2, arg3}) + stub := fake.GetStateMetadataStub + fakeReturns := fake.getStateMetadataReturns + fake.recordInvocation("GetStateMetadata", []interface{}{arg1, arg2, arg3}) + fake.getStateMetadataMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricRWSet) GetStateMetadataCallCount() int { + fake.getStateMetadataMutex.RLock() + defer fake.getStateMetadataMutex.RUnlock() + return len(fake.getStateMetadataArgsForCall) +} + +func (fake *FabricRWSet) GetStateMetadataCalls(stub func(driver.Namespace, driver.PKey, ...driver.GetStateOpt) (driver.Metadata, error)) { + fake.getStateMetadataMutex.Lock() + defer fake.getStateMetadataMutex.Unlock() + fake.GetStateMetadataStub = stub +} + +func (fake *FabricRWSet) GetStateMetadataArgsForCall(i int) (driver.Namespace, driver.PKey, []driver.GetStateOpt) { + fake.getStateMetadataMutex.RLock() + defer fake.getStateMetadataMutex.RUnlock() + argsForCall := fake.getStateMetadataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FabricRWSet) GetStateMetadataReturns(result1 driver.Metadata, result2 error) { + fake.getStateMetadataMutex.Lock() + defer fake.getStateMetadataMutex.Unlock() + fake.GetStateMetadataStub = nil + fake.getStateMetadataReturns = struct { + result1 driver.Metadata + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) GetStateMetadataReturnsOnCall(i int, result1 driver.Metadata, result2 error) { + fake.getStateMetadataMutex.Lock() + defer fake.getStateMetadataMutex.Unlock() + fake.GetStateMetadataStub = nil + if fake.getStateMetadataReturnsOnCall == nil { + fake.getStateMetadataReturnsOnCall = make(map[int]struct { + result1 driver.Metadata + result2 error + }) + } + fake.getStateMetadataReturnsOnCall[i] = struct { + result1 driver.Metadata + result2 error + }{result1, result2} +} + +func (fake *FabricRWSet) GetWriteAt(arg1 driver.Namespace, arg2 int) (driver.PKey, driver.RawValue, error) { + fake.getWriteAtMutex.Lock() + ret, specificReturn := fake.getWriteAtReturnsOnCall[len(fake.getWriteAtArgsForCall)] + fake.getWriteAtArgsForCall = append(fake.getWriteAtArgsForCall, struct { + arg1 driver.Namespace + arg2 int + }{arg1, arg2}) + stub := fake.GetWriteAtStub + fakeReturns := fake.getWriteAtReturns + fake.recordInvocation("GetWriteAt", []interface{}{arg1, arg2}) + fake.getWriteAtMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FabricRWSet) GetWriteAtCallCount() int { + fake.getWriteAtMutex.RLock() + defer fake.getWriteAtMutex.RUnlock() + return len(fake.getWriteAtArgsForCall) +} + +func (fake *FabricRWSet) GetWriteAtCalls(stub func(driver.Namespace, int) (driver.PKey, driver.RawValue, error)) { + fake.getWriteAtMutex.Lock() + defer fake.getWriteAtMutex.Unlock() + fake.GetWriteAtStub = stub +} + +func (fake *FabricRWSet) GetWriteAtArgsForCall(i int) (driver.Namespace, int) { + fake.getWriteAtMutex.RLock() + defer fake.getWriteAtMutex.RUnlock() + argsForCall := fake.getWriteAtArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FabricRWSet) GetWriteAtReturns(result1 driver.PKey, result2 driver.RawValue, result3 error) { + fake.getWriteAtMutex.Lock() + defer fake.getWriteAtMutex.Unlock() + fake.GetWriteAtStub = nil + fake.getWriteAtReturns = struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + }{result1, result2, result3} +} + +func (fake *FabricRWSet) GetWriteAtReturnsOnCall(i int, result1 driver.PKey, result2 driver.RawValue, result3 error) { + fake.getWriteAtMutex.Lock() + defer fake.getWriteAtMutex.Unlock() + fake.GetWriteAtStub = nil + if fake.getWriteAtReturnsOnCall == nil { + fake.getWriteAtReturnsOnCall = make(map[int]struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + }) + } + fake.getWriteAtReturnsOnCall[i] = struct { + result1 driver.PKey + result2 driver.RawValue + result3 error + }{result1, result2, result3} +} + +func (fake *FabricRWSet) IsClosed() bool { + fake.isClosedMutex.Lock() + ret, specificReturn := fake.isClosedReturnsOnCall[len(fake.isClosedArgsForCall)] + fake.isClosedArgsForCall = append(fake.isClosedArgsForCall, struct { + }{}) + stub := fake.IsClosedStub + fakeReturns := fake.isClosedReturns + fake.recordInvocation("IsClosed", []interface{}{}) + fake.isClosedMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) IsClosedCallCount() int { + fake.isClosedMutex.RLock() + defer fake.isClosedMutex.RUnlock() + return len(fake.isClosedArgsForCall) +} + +func (fake *FabricRWSet) IsClosedCalls(stub func() bool) { + fake.isClosedMutex.Lock() + defer fake.isClosedMutex.Unlock() + fake.IsClosedStub = stub +} + +func (fake *FabricRWSet) IsClosedReturns(result1 bool) { + fake.isClosedMutex.Lock() + defer fake.isClosedMutex.Unlock() + fake.IsClosedStub = nil + fake.isClosedReturns = struct { + result1 bool + }{result1} +} + +func (fake *FabricRWSet) IsClosedReturnsOnCall(i int, result1 bool) { + fake.isClosedMutex.Lock() + defer fake.isClosedMutex.Unlock() + fake.IsClosedStub = nil + if fake.isClosedReturnsOnCall == nil { + fake.isClosedReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isClosedReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FabricRWSet) IsValid() error { + fake.isValidMutex.Lock() + ret, specificReturn := fake.isValidReturnsOnCall[len(fake.isValidArgsForCall)] + fake.isValidArgsForCall = append(fake.isValidArgsForCall, struct { + }{}) + stub := fake.IsValidStub + fakeReturns := fake.isValidReturns + fake.recordInvocation("IsValid", []interface{}{}) + fake.isValidMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) IsValidCallCount() int { + fake.isValidMutex.RLock() + defer fake.isValidMutex.RUnlock() + return len(fake.isValidArgsForCall) +} + +func (fake *FabricRWSet) IsValidCalls(stub func() error) { + fake.isValidMutex.Lock() + defer fake.isValidMutex.Unlock() + fake.IsValidStub = stub +} + +func (fake *FabricRWSet) IsValidReturns(result1 error) { + fake.isValidMutex.Lock() + defer fake.isValidMutex.Unlock() + fake.IsValidStub = nil + fake.isValidReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) IsValidReturnsOnCall(i int, result1 error) { + fake.isValidMutex.Lock() + defer fake.isValidMutex.Unlock() + fake.IsValidStub = nil + if fake.isValidReturnsOnCall == nil { + fake.isValidReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.isValidReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) Namespaces() []driver.Namespace { + fake.namespacesMutex.Lock() + ret, specificReturn := fake.namespacesReturnsOnCall[len(fake.namespacesArgsForCall)] + fake.namespacesArgsForCall = append(fake.namespacesArgsForCall, struct { + }{}) + stub := fake.NamespacesStub + fakeReturns := fake.namespacesReturns + fake.recordInvocation("Namespaces", []interface{}{}) + fake.namespacesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) NamespacesCallCount() int { + fake.namespacesMutex.RLock() + defer fake.namespacesMutex.RUnlock() + return len(fake.namespacesArgsForCall) +} + +func (fake *FabricRWSet) NamespacesCalls(stub func() []driver.Namespace) { + fake.namespacesMutex.Lock() + defer fake.namespacesMutex.Unlock() + fake.NamespacesStub = stub +} + +func (fake *FabricRWSet) NamespacesReturns(result1 []driver.Namespace) { + fake.namespacesMutex.Lock() + defer fake.namespacesMutex.Unlock() + fake.NamespacesStub = nil + fake.namespacesReturns = struct { + result1 []driver.Namespace + }{result1} +} + +func (fake *FabricRWSet) NamespacesReturnsOnCall(i int, result1 []driver.Namespace) { + fake.namespacesMutex.Lock() + defer fake.namespacesMutex.Unlock() + fake.NamespacesStub = nil + if fake.namespacesReturnsOnCall == nil { + fake.namespacesReturnsOnCall = make(map[int]struct { + result1 []driver.Namespace + }) + } + fake.namespacesReturnsOnCall[i] = struct { + result1 []driver.Namespace + }{result1} +} + +func (fake *FabricRWSet) NumReads(arg1 driver.Namespace) int { + fake.numReadsMutex.Lock() + ret, specificReturn := fake.numReadsReturnsOnCall[len(fake.numReadsArgsForCall)] + fake.numReadsArgsForCall = append(fake.numReadsArgsForCall, struct { + arg1 driver.Namespace + }{arg1}) + stub := fake.NumReadsStub + fakeReturns := fake.numReadsReturns + fake.recordInvocation("NumReads", []interface{}{arg1}) + fake.numReadsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) NumReadsCallCount() int { + fake.numReadsMutex.RLock() + defer fake.numReadsMutex.RUnlock() + return len(fake.numReadsArgsForCall) +} + +func (fake *FabricRWSet) NumReadsCalls(stub func(driver.Namespace) int) { + fake.numReadsMutex.Lock() + defer fake.numReadsMutex.Unlock() + fake.NumReadsStub = stub +} + +func (fake *FabricRWSet) NumReadsArgsForCall(i int) driver.Namespace { + fake.numReadsMutex.RLock() + defer fake.numReadsMutex.RUnlock() + argsForCall := fake.numReadsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricRWSet) NumReadsReturns(result1 int) { + fake.numReadsMutex.Lock() + defer fake.numReadsMutex.Unlock() + fake.NumReadsStub = nil + fake.numReadsReturns = struct { + result1 int + }{result1} +} + +func (fake *FabricRWSet) NumReadsReturnsOnCall(i int, result1 int) { + fake.numReadsMutex.Lock() + defer fake.numReadsMutex.Unlock() + fake.NumReadsStub = nil + if fake.numReadsReturnsOnCall == nil { + fake.numReadsReturnsOnCall = make(map[int]struct { + result1 int + }) + } + fake.numReadsReturnsOnCall[i] = struct { + result1 int + }{result1} +} + +func (fake *FabricRWSet) NumWrites(arg1 driver.Namespace) int { + fake.numWritesMutex.Lock() + ret, specificReturn := fake.numWritesReturnsOnCall[len(fake.numWritesArgsForCall)] + fake.numWritesArgsForCall = append(fake.numWritesArgsForCall, struct { + arg1 driver.Namespace + }{arg1}) + stub := fake.NumWritesStub + fakeReturns := fake.numWritesReturns + fake.recordInvocation("NumWrites", []interface{}{arg1}) + fake.numWritesMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) NumWritesCallCount() int { + fake.numWritesMutex.RLock() + defer fake.numWritesMutex.RUnlock() + return len(fake.numWritesArgsForCall) +} + +func (fake *FabricRWSet) NumWritesCalls(stub func(driver.Namespace) int) { + fake.numWritesMutex.Lock() + defer fake.numWritesMutex.Unlock() + fake.NumWritesStub = stub +} + +func (fake *FabricRWSet) NumWritesArgsForCall(i int) driver.Namespace { + fake.numWritesMutex.RLock() + defer fake.numWritesMutex.RUnlock() + argsForCall := fake.numWritesArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricRWSet) NumWritesReturns(result1 int) { + fake.numWritesMutex.Lock() + defer fake.numWritesMutex.Unlock() + fake.NumWritesStub = nil + fake.numWritesReturns = struct { + result1 int + }{result1} +} + +func (fake *FabricRWSet) NumWritesReturnsOnCall(i int, result1 int) { + fake.numWritesMutex.Lock() + defer fake.numWritesMutex.Unlock() + fake.NumWritesStub = nil + if fake.numWritesReturnsOnCall == nil { + fake.numWritesReturnsOnCall = make(map[int]struct { + result1 int + }) + } + fake.numWritesReturnsOnCall[i] = struct { + result1 int + }{result1} +} + +func (fake *FabricRWSet) SetState(arg1 driver.Namespace, arg2 driver.PKey, arg3 driver.RawValue) error { + fake.setStateMutex.Lock() + ret, specificReturn := fake.setStateReturnsOnCall[len(fake.setStateArgsForCall)] + fake.setStateArgsForCall = append(fake.setStateArgsForCall, struct { + arg1 driver.Namespace + arg2 driver.PKey + arg3 driver.RawValue + }{arg1, arg2, arg3}) + stub := fake.SetStateStub + fakeReturns := fake.setStateReturns + fake.recordInvocation("SetState", []interface{}{arg1, arg2, arg3}) + fake.setStateMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) SetStateCallCount() int { + fake.setStateMutex.RLock() + defer fake.setStateMutex.RUnlock() + return len(fake.setStateArgsForCall) +} + +func (fake *FabricRWSet) SetStateCalls(stub func(driver.Namespace, driver.PKey, driver.RawValue) error) { + fake.setStateMutex.Lock() + defer fake.setStateMutex.Unlock() + fake.SetStateStub = stub +} + +func (fake *FabricRWSet) SetStateArgsForCall(i int) (driver.Namespace, driver.PKey, driver.RawValue) { + fake.setStateMutex.RLock() + defer fake.setStateMutex.RUnlock() + argsForCall := fake.setStateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FabricRWSet) SetStateReturns(result1 error) { + fake.setStateMutex.Lock() + defer fake.setStateMutex.Unlock() + fake.SetStateStub = nil + fake.setStateReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) SetStateReturnsOnCall(i int, result1 error) { + fake.setStateMutex.Lock() + defer fake.setStateMutex.Unlock() + fake.SetStateStub = nil + if fake.setStateReturnsOnCall == nil { + fake.setStateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setStateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) SetStateMetadata(arg1 driver.Namespace, arg2 driver.PKey, arg3 driver.Metadata) error { + fake.setStateMetadataMutex.Lock() + ret, specificReturn := fake.setStateMetadataReturnsOnCall[len(fake.setStateMetadataArgsForCall)] + fake.setStateMetadataArgsForCall = append(fake.setStateMetadataArgsForCall, struct { + arg1 driver.Namespace + arg2 driver.PKey + arg3 driver.Metadata + }{arg1, arg2, arg3}) + stub := fake.SetStateMetadataStub + fakeReturns := fake.setStateMetadataReturns + fake.recordInvocation("SetStateMetadata", []interface{}{arg1, arg2, arg3}) + fake.setStateMetadataMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricRWSet) SetStateMetadataCallCount() int { + fake.setStateMetadataMutex.RLock() + defer fake.setStateMetadataMutex.RUnlock() + return len(fake.setStateMetadataArgsForCall) +} + +func (fake *FabricRWSet) SetStateMetadataCalls(stub func(driver.Namespace, driver.PKey, driver.Metadata) error) { + fake.setStateMetadataMutex.Lock() + defer fake.setStateMetadataMutex.Unlock() + fake.SetStateMetadataStub = stub +} + +func (fake *FabricRWSet) SetStateMetadataArgsForCall(i int) (driver.Namespace, driver.PKey, driver.Metadata) { + fake.setStateMetadataMutex.RLock() + defer fake.setStateMetadataMutex.RUnlock() + argsForCall := fake.setStateMetadataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FabricRWSet) SetStateMetadataReturns(result1 error) { + fake.setStateMetadataMutex.Lock() + defer fake.setStateMetadataMutex.Unlock() + fake.SetStateMetadataStub = nil + fake.setStateMetadataReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) SetStateMetadataReturnsOnCall(i int, result1 error) { + fake.setStateMetadataMutex.Lock() + defer fake.setStateMetadataMutex.Unlock() + fake.SetStateMetadataStub = nil + if fake.setStateMetadataReturnsOnCall == nil { + fake.setStateMetadataReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setStateMetadataReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricRWSet) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.addReadAtMutex.RLock() + defer fake.addReadAtMutex.RUnlock() + fake.appendRWSetMutex.RLock() + defer fake.appendRWSetMutex.RUnlock() + fake.bytesMutex.RLock() + defer fake.bytesMutex.RUnlock() + fake.clearMutex.RLock() + defer fake.clearMutex.RUnlock() + fake.deleteStateMutex.RLock() + defer fake.deleteStateMutex.RUnlock() + fake.doneMutex.RLock() + defer fake.doneMutex.RUnlock() + fake.equalsMutex.RLock() + defer fake.equalsMutex.RUnlock() + fake.getDirectStateMutex.RLock() + defer fake.getDirectStateMutex.RUnlock() + fake.getReadAtMutex.RLock() + defer fake.getReadAtMutex.RUnlock() + fake.getReadKeyAtMutex.RLock() + defer fake.getReadKeyAtMutex.RUnlock() + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + fake.getStateMetadataMutex.RLock() + defer fake.getStateMetadataMutex.RUnlock() + fake.getWriteAtMutex.RLock() + defer fake.getWriteAtMutex.RUnlock() + fake.isClosedMutex.RLock() + defer fake.isClosedMutex.RUnlock() + fake.isValidMutex.RLock() + defer fake.isValidMutex.RUnlock() + fake.namespacesMutex.RLock() + defer fake.namespacesMutex.RUnlock() + fake.numReadsMutex.RLock() + defer fake.numReadsMutex.RUnlock() + fake.numWritesMutex.RLock() + defer fake.numWritesMutex.RUnlock() + fake.setStateMutex.RLock() + defer fake.setStateMutex.RUnlock() + fake.setStateMetadataMutex.RLock() + defer fake.setStateMetadataMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FabricRWSet) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fsc.FabricRWSet = new(FabricRWSet) diff --git a/token/services/network/fabric/endorsement/fsc/mock/fabric_transaction.go b/token/services/network/fabric/endorsement/fsc/mock/fabric_transaction.go new file mode 100644 index 000000000..6f337a37a --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/mock/fabric_transaction.go @@ -0,0 +1,2812 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver" + "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" +) + +type FabricTransaction struct { + AppendParameterStub func([]byte) + appendParameterMutex sync.RWMutex + appendParameterArgsForCall []struct { + arg1 []byte + } + AppendProposalResponseStub func(driver.ProposalResponse) error + appendProposalResponseMutex sync.RWMutex + appendProposalResponseArgsForCall []struct { + arg1 driver.ProposalResponse + } + appendProposalResponseReturns struct { + result1 error + } + appendProposalResponseReturnsOnCall map[int]struct { + result1 error + } + BytesStub func() ([]byte, error) + bytesMutex sync.RWMutex + bytesArgsForCall []struct { + } + bytesReturns struct { + result1 []byte + result2 error + } + bytesReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + BytesNoTransientStub func() ([]byte, error) + bytesNoTransientMutex sync.RWMutex + bytesNoTransientArgsForCall []struct { + } + bytesNoTransientReturns struct { + result1 []byte + result2 error + } + bytesNoTransientReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + ChaincodeStub func() string + chaincodeMutex sync.RWMutex + chaincodeArgsForCall []struct { + } + chaincodeReturns struct { + result1 string + } + chaincodeReturnsOnCall map[int]struct { + result1 string + } + ChaincodeVersionStub func() string + chaincodeVersionMutex sync.RWMutex + chaincodeVersionArgsForCall []struct { + } + chaincodeVersionReturns struct { + result1 string + } + chaincodeVersionReturnsOnCall map[int]struct { + result1 string + } + ChannelStub func() string + channelMutex sync.RWMutex + channelArgsForCall []struct { + } + channelReturns struct { + result1 string + } + channelReturnsOnCall map[int]struct { + result1 string + } + CloseStub func() + closeMutex sync.RWMutex + closeArgsForCall []struct { + } + CreatorStub func() view.Identity + creatorMutex sync.RWMutex + creatorArgsForCall []struct { + } + creatorReturns struct { + result1 view.Identity + } + creatorReturnsOnCall map[int]struct { + result1 view.Identity + } + DoneStub func() error + doneMutex sync.RWMutex + doneArgsForCall []struct { + } + doneReturns struct { + result1 error + } + doneReturnsOnCall map[int]struct { + result1 error + } + EndorseStub func() error + endorseMutex sync.RWMutex + endorseArgsForCall []struct { + } + endorseReturns struct { + result1 error + } + endorseReturnsOnCall map[int]struct { + result1 error + } + EndorseProposalStub func() error + endorseProposalMutex sync.RWMutex + endorseProposalArgsForCall []struct { + } + endorseProposalReturns struct { + result1 error + } + endorseProposalReturnsOnCall map[int]struct { + result1 error + } + EndorseProposalResponseStub func() error + endorseProposalResponseMutex sync.RWMutex + endorseProposalResponseArgsForCall []struct { + } + endorseProposalResponseReturns struct { + result1 error + } + endorseProposalResponseReturnsOnCall map[int]struct { + result1 error + } + EndorseProposalResponseWithIdentityStub func(view.Identity) error + endorseProposalResponseWithIdentityMutex sync.RWMutex + endorseProposalResponseWithIdentityArgsForCall []struct { + arg1 view.Identity + } + endorseProposalResponseWithIdentityReturns struct { + result1 error + } + endorseProposalResponseWithIdentityReturnsOnCall map[int]struct { + result1 error + } + EndorseProposalWithIdentityStub func(view.Identity) error + endorseProposalWithIdentityMutex sync.RWMutex + endorseProposalWithIdentityArgsForCall []struct { + arg1 view.Identity + } + endorseProposalWithIdentityReturns struct { + result1 error + } + endorseProposalWithIdentityReturnsOnCall map[int]struct { + result1 error + } + EndorseWithIdentityStub func(view.Identity) error + endorseWithIdentityMutex sync.RWMutex + endorseWithIdentityArgsForCall []struct { + arg1 view.Identity + } + endorseWithIdentityReturns struct { + result1 error + } + endorseWithIdentityReturnsOnCall map[int]struct { + result1 error + } + EndorseWithSignerStub func(view.Identity, driver.Signer) error + endorseWithSignerMutex sync.RWMutex + endorseWithSignerArgsForCall []struct { + arg1 view.Identity + arg2 driver.Signer + } + endorseWithSignerReturns struct { + result1 error + } + endorseWithSignerReturnsOnCall map[int]struct { + result1 error + } + EnvelopeStub func() (driver.Envelope, error) + envelopeMutex sync.RWMutex + envelopeArgsForCall []struct { + } + envelopeReturns struct { + result1 driver.Envelope + result2 error + } + envelopeReturnsOnCall map[int]struct { + result1 driver.Envelope + result2 error + } + FromStub func(driver.Transaction) error + fromMutex sync.RWMutex + fromArgsForCall []struct { + arg1 driver.Transaction + } + fromReturns struct { + result1 error + } + fromReturnsOnCall map[int]struct { + result1 error + } + FunctionStub func() string + functionMutex sync.RWMutex + functionArgsForCall []struct { + } + functionReturns struct { + result1 string + } + functionReturnsOnCall map[int]struct { + result1 string + } + FunctionAndParametersStub func() (string, []string) + functionAndParametersMutex sync.RWMutex + functionAndParametersArgsForCall []struct { + } + functionAndParametersReturns struct { + result1 string + result2 []string + } + functionAndParametersReturnsOnCall map[int]struct { + result1 string + result2 []string + } + GetRWSetStub func() (driver.RWSet, error) + getRWSetMutex sync.RWMutex + getRWSetArgsForCall []struct { + } + getRWSetReturns struct { + result1 driver.RWSet + result2 error + } + getRWSetReturnsOnCall map[int]struct { + result1 driver.RWSet + result2 error + } + IDStub func() string + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 string + } + iDReturnsOnCall map[int]struct { + result1 string + } + NetworkStub func() string + networkMutex sync.RWMutex + networkArgsForCall []struct { + } + networkReturns struct { + result1 string + } + networkReturnsOnCall map[int]struct { + result1 string + } + NonceStub func() []byte + nonceMutex sync.RWMutex + nonceArgsForCall []struct { + } + nonceReturns struct { + result1 []byte + } + nonceReturnsOnCall map[int]struct { + result1 []byte + } + ParametersStub func() [][]byte + parametersMutex sync.RWMutex + parametersArgsForCall []struct { + } + parametersReturns struct { + result1 [][]byte + } + parametersReturnsOnCall map[int]struct { + result1 [][]byte + } + ProposalStub func() driver.Proposal + proposalMutex sync.RWMutex + proposalArgsForCall []struct { + } + proposalReturns struct { + result1 driver.Proposal + } + proposalReturnsOnCall map[int]struct { + result1 driver.Proposal + } + ProposalHasBeenEndorsedByStub func(view.Identity) error + proposalHasBeenEndorsedByMutex sync.RWMutex + proposalHasBeenEndorsedByArgsForCall []struct { + arg1 view.Identity + } + proposalHasBeenEndorsedByReturns struct { + result1 error + } + proposalHasBeenEndorsedByReturnsOnCall map[int]struct { + result1 error + } + ProposalResponseStub func() ([]byte, error) + proposalResponseMutex sync.RWMutex + proposalResponseArgsForCall []struct { + } + proposalResponseReturns struct { + result1 []byte + result2 error + } + proposalResponseReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + ProposalResponsesStub func() ([]driver.ProposalResponse, error) + proposalResponsesMutex sync.RWMutex + proposalResponsesArgsForCall []struct { + } + proposalResponsesReturns struct { + result1 []driver.ProposalResponse + result2 error + } + proposalResponsesReturnsOnCall map[int]struct { + result1 []driver.ProposalResponse + result2 error + } + RWSStub func() driver.RWSet + rWSMutex sync.RWMutex + rWSArgsForCall []struct { + } + rWSReturns struct { + result1 driver.RWSet + } + rWSReturnsOnCall map[int]struct { + result1 driver.RWSet + } + RawStub func() ([]byte, error) + rawMutex sync.RWMutex + rawArgsForCall []struct { + } + rawReturns struct { + result1 []byte + result2 error + } + rawReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + ResetTransientStub func() + resetTransientMutex sync.RWMutex + resetTransientArgsForCall []struct { + } + ResultsStub func() ([]byte, error) + resultsMutex sync.RWMutex + resultsArgsForCall []struct { + } + resultsReturns struct { + result1 []byte + result2 error + } + resultsReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + SetFromBytesStub func([]byte) error + setFromBytesMutex sync.RWMutex + setFromBytesArgsForCall []struct { + arg1 []byte + } + setFromBytesReturns struct { + result1 error + } + setFromBytesReturnsOnCall map[int]struct { + result1 error + } + SetFromEnvelopeBytesStub func([]byte) error + setFromEnvelopeBytesMutex sync.RWMutex + setFromEnvelopeBytesArgsForCall []struct { + arg1 []byte + } + setFromEnvelopeBytesReturns struct { + result1 error + } + setFromEnvelopeBytesReturnsOnCall map[int]struct { + result1 error + } + SetParameterAtStub func(int, []byte) error + setParameterAtMutex sync.RWMutex + setParameterAtArgsForCall []struct { + arg1 int + arg2 []byte + } + setParameterAtReturns struct { + result1 error + } + setParameterAtReturnsOnCall map[int]struct { + result1 error + } + SetProposalStub func(string, string, string, ...string) + setProposalMutex sync.RWMutex + setProposalArgsForCall []struct { + arg1 string + arg2 string + arg3 string + arg4 []string + } + SetRWSetStub func() error + setRWSetMutex sync.RWMutex + setRWSetArgsForCall []struct { + } + setRWSetReturns struct { + result1 error + } + setRWSetReturnsOnCall map[int]struct { + result1 error + } + SignedProposalStub func() driver.SignedProposal + signedProposalMutex sync.RWMutex + signedProposalArgsForCall []struct { + } + signedProposalReturns struct { + result1 driver.SignedProposal + } + signedProposalReturnsOnCall map[int]struct { + result1 driver.SignedProposal + } + StoreTransientStub func() error + storeTransientMutex sync.RWMutex + storeTransientArgsForCall []struct { + } + storeTransientReturns struct { + result1 error + } + storeTransientReturnsOnCall map[int]struct { + result1 error + } + TransientStub func() driver.TransientMap + transientMutex sync.RWMutex + transientArgsForCall []struct { + } + transientReturns struct { + result1 driver.TransientMap + } + transientReturnsOnCall map[int]struct { + result1 driver.TransientMap + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FabricTransaction) AppendParameter(arg1 []byte) { + var arg1Copy []byte + if arg1 != nil { + arg1Copy = make([]byte, len(arg1)) + copy(arg1Copy, arg1) + } + fake.appendParameterMutex.Lock() + fake.appendParameterArgsForCall = append(fake.appendParameterArgsForCall, struct { + arg1 []byte + }{arg1Copy}) + stub := fake.AppendParameterStub + fake.recordInvocation("AppendParameter", []interface{}{arg1Copy}) + fake.appendParameterMutex.Unlock() + if stub != nil { + fake.AppendParameterStub(arg1) + } +} + +func (fake *FabricTransaction) AppendParameterCallCount() int { + fake.appendParameterMutex.RLock() + defer fake.appendParameterMutex.RUnlock() + return len(fake.appendParameterArgsForCall) +} + +func (fake *FabricTransaction) AppendParameterCalls(stub func([]byte)) { + fake.appendParameterMutex.Lock() + defer fake.appendParameterMutex.Unlock() + fake.AppendParameterStub = stub +} + +func (fake *FabricTransaction) AppendParameterArgsForCall(i int) []byte { + fake.appendParameterMutex.RLock() + defer fake.appendParameterMutex.RUnlock() + argsForCall := fake.appendParameterArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricTransaction) AppendProposalResponse(arg1 driver.ProposalResponse) error { + fake.appendProposalResponseMutex.Lock() + ret, specificReturn := fake.appendProposalResponseReturnsOnCall[len(fake.appendProposalResponseArgsForCall)] + fake.appendProposalResponseArgsForCall = append(fake.appendProposalResponseArgsForCall, struct { + arg1 driver.ProposalResponse + }{arg1}) + stub := fake.AppendProposalResponseStub + fakeReturns := fake.appendProposalResponseReturns + fake.recordInvocation("AppendProposalResponse", []interface{}{arg1}) + fake.appendProposalResponseMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) AppendProposalResponseCallCount() int { + fake.appendProposalResponseMutex.RLock() + defer fake.appendProposalResponseMutex.RUnlock() + return len(fake.appendProposalResponseArgsForCall) +} + +func (fake *FabricTransaction) AppendProposalResponseCalls(stub func(driver.ProposalResponse) error) { + fake.appendProposalResponseMutex.Lock() + defer fake.appendProposalResponseMutex.Unlock() + fake.AppendProposalResponseStub = stub +} + +func (fake *FabricTransaction) AppendProposalResponseArgsForCall(i int) driver.ProposalResponse { + fake.appendProposalResponseMutex.RLock() + defer fake.appendProposalResponseMutex.RUnlock() + argsForCall := fake.appendProposalResponseArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricTransaction) AppendProposalResponseReturns(result1 error) { + fake.appendProposalResponseMutex.Lock() + defer fake.appendProposalResponseMutex.Unlock() + fake.AppendProposalResponseStub = nil + fake.appendProposalResponseReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) AppendProposalResponseReturnsOnCall(i int, result1 error) { + fake.appendProposalResponseMutex.Lock() + defer fake.appendProposalResponseMutex.Unlock() + fake.AppendProposalResponseStub = nil + if fake.appendProposalResponseReturnsOnCall == nil { + fake.appendProposalResponseReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.appendProposalResponseReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) Bytes() ([]byte, error) { + fake.bytesMutex.Lock() + ret, specificReturn := fake.bytesReturnsOnCall[len(fake.bytesArgsForCall)] + fake.bytesArgsForCall = append(fake.bytesArgsForCall, struct { + }{}) + stub := fake.BytesStub + fakeReturns := fake.bytesReturns + fake.recordInvocation("Bytes", []interface{}{}) + fake.bytesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricTransaction) BytesCallCount() int { + fake.bytesMutex.RLock() + defer fake.bytesMutex.RUnlock() + return len(fake.bytesArgsForCall) +} + +func (fake *FabricTransaction) BytesCalls(stub func() ([]byte, error)) { + fake.bytesMutex.Lock() + defer fake.bytesMutex.Unlock() + fake.BytesStub = stub +} + +func (fake *FabricTransaction) BytesReturns(result1 []byte, result2 error) { + fake.bytesMutex.Lock() + defer fake.bytesMutex.Unlock() + fake.BytesStub = nil + fake.bytesReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) BytesReturnsOnCall(i int, result1 []byte, result2 error) { + fake.bytesMutex.Lock() + defer fake.bytesMutex.Unlock() + fake.BytesStub = nil + if fake.bytesReturnsOnCall == nil { + fake.bytesReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.bytesReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) BytesNoTransient() ([]byte, error) { + fake.bytesNoTransientMutex.Lock() + ret, specificReturn := fake.bytesNoTransientReturnsOnCall[len(fake.bytesNoTransientArgsForCall)] + fake.bytesNoTransientArgsForCall = append(fake.bytesNoTransientArgsForCall, struct { + }{}) + stub := fake.BytesNoTransientStub + fakeReturns := fake.bytesNoTransientReturns + fake.recordInvocation("BytesNoTransient", []interface{}{}) + fake.bytesNoTransientMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricTransaction) BytesNoTransientCallCount() int { + fake.bytesNoTransientMutex.RLock() + defer fake.bytesNoTransientMutex.RUnlock() + return len(fake.bytesNoTransientArgsForCall) +} + +func (fake *FabricTransaction) BytesNoTransientCalls(stub func() ([]byte, error)) { + fake.bytesNoTransientMutex.Lock() + defer fake.bytesNoTransientMutex.Unlock() + fake.BytesNoTransientStub = stub +} + +func (fake *FabricTransaction) BytesNoTransientReturns(result1 []byte, result2 error) { + fake.bytesNoTransientMutex.Lock() + defer fake.bytesNoTransientMutex.Unlock() + fake.BytesNoTransientStub = nil + fake.bytesNoTransientReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) BytesNoTransientReturnsOnCall(i int, result1 []byte, result2 error) { + fake.bytesNoTransientMutex.Lock() + defer fake.bytesNoTransientMutex.Unlock() + fake.BytesNoTransientStub = nil + if fake.bytesNoTransientReturnsOnCall == nil { + fake.bytesNoTransientReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.bytesNoTransientReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) Chaincode() string { + fake.chaincodeMutex.Lock() + ret, specificReturn := fake.chaincodeReturnsOnCall[len(fake.chaincodeArgsForCall)] + fake.chaincodeArgsForCall = append(fake.chaincodeArgsForCall, struct { + }{}) + stub := fake.ChaincodeStub + fakeReturns := fake.chaincodeReturns + fake.recordInvocation("Chaincode", []interface{}{}) + fake.chaincodeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) ChaincodeCallCount() int { + fake.chaincodeMutex.RLock() + defer fake.chaincodeMutex.RUnlock() + return len(fake.chaincodeArgsForCall) +} + +func (fake *FabricTransaction) ChaincodeCalls(stub func() string) { + fake.chaincodeMutex.Lock() + defer fake.chaincodeMutex.Unlock() + fake.ChaincodeStub = stub +} + +func (fake *FabricTransaction) ChaincodeReturns(result1 string) { + fake.chaincodeMutex.Lock() + defer fake.chaincodeMutex.Unlock() + fake.ChaincodeStub = nil + fake.chaincodeReturns = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) ChaincodeReturnsOnCall(i int, result1 string) { + fake.chaincodeMutex.Lock() + defer fake.chaincodeMutex.Unlock() + fake.ChaincodeStub = nil + if fake.chaincodeReturnsOnCall == nil { + fake.chaincodeReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.chaincodeReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) ChaincodeVersion() string { + fake.chaincodeVersionMutex.Lock() + ret, specificReturn := fake.chaincodeVersionReturnsOnCall[len(fake.chaincodeVersionArgsForCall)] + fake.chaincodeVersionArgsForCall = append(fake.chaincodeVersionArgsForCall, struct { + }{}) + stub := fake.ChaincodeVersionStub + fakeReturns := fake.chaincodeVersionReturns + fake.recordInvocation("ChaincodeVersion", []interface{}{}) + fake.chaincodeVersionMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) ChaincodeVersionCallCount() int { + fake.chaincodeVersionMutex.RLock() + defer fake.chaincodeVersionMutex.RUnlock() + return len(fake.chaincodeVersionArgsForCall) +} + +func (fake *FabricTransaction) ChaincodeVersionCalls(stub func() string) { + fake.chaincodeVersionMutex.Lock() + defer fake.chaincodeVersionMutex.Unlock() + fake.ChaincodeVersionStub = stub +} + +func (fake *FabricTransaction) ChaincodeVersionReturns(result1 string) { + fake.chaincodeVersionMutex.Lock() + defer fake.chaincodeVersionMutex.Unlock() + fake.ChaincodeVersionStub = nil + fake.chaincodeVersionReturns = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) ChaincodeVersionReturnsOnCall(i int, result1 string) { + fake.chaincodeVersionMutex.Lock() + defer fake.chaincodeVersionMutex.Unlock() + fake.ChaincodeVersionStub = nil + if fake.chaincodeVersionReturnsOnCall == nil { + fake.chaincodeVersionReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.chaincodeVersionReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) Channel() string { + fake.channelMutex.Lock() + ret, specificReturn := fake.channelReturnsOnCall[len(fake.channelArgsForCall)] + fake.channelArgsForCall = append(fake.channelArgsForCall, struct { + }{}) + stub := fake.ChannelStub + fakeReturns := fake.channelReturns + fake.recordInvocation("Channel", []interface{}{}) + fake.channelMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) ChannelCallCount() int { + fake.channelMutex.RLock() + defer fake.channelMutex.RUnlock() + return len(fake.channelArgsForCall) +} + +func (fake *FabricTransaction) ChannelCalls(stub func() string) { + fake.channelMutex.Lock() + defer fake.channelMutex.Unlock() + fake.ChannelStub = stub +} + +func (fake *FabricTransaction) ChannelReturns(result1 string) { + fake.channelMutex.Lock() + defer fake.channelMutex.Unlock() + fake.ChannelStub = nil + fake.channelReturns = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) ChannelReturnsOnCall(i int, result1 string) { + fake.channelMutex.Lock() + defer fake.channelMutex.Unlock() + fake.ChannelStub = nil + if fake.channelReturnsOnCall == nil { + fake.channelReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.channelReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) Close() { + fake.closeMutex.Lock() + fake.closeArgsForCall = append(fake.closeArgsForCall, struct { + }{}) + stub := fake.CloseStub + fake.recordInvocation("Close", []interface{}{}) + fake.closeMutex.Unlock() + if stub != nil { + fake.CloseStub() + } +} + +func (fake *FabricTransaction) CloseCallCount() int { + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + return len(fake.closeArgsForCall) +} + +func (fake *FabricTransaction) CloseCalls(stub func()) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = stub +} + +func (fake *FabricTransaction) Creator() view.Identity { + fake.creatorMutex.Lock() + ret, specificReturn := fake.creatorReturnsOnCall[len(fake.creatorArgsForCall)] + fake.creatorArgsForCall = append(fake.creatorArgsForCall, struct { + }{}) + stub := fake.CreatorStub + fakeReturns := fake.creatorReturns + fake.recordInvocation("Creator", []interface{}{}) + fake.creatorMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) CreatorCallCount() int { + fake.creatorMutex.RLock() + defer fake.creatorMutex.RUnlock() + return len(fake.creatorArgsForCall) +} + +func (fake *FabricTransaction) CreatorCalls(stub func() view.Identity) { + fake.creatorMutex.Lock() + defer fake.creatorMutex.Unlock() + fake.CreatorStub = stub +} + +func (fake *FabricTransaction) CreatorReturns(result1 view.Identity) { + fake.creatorMutex.Lock() + defer fake.creatorMutex.Unlock() + fake.CreatorStub = nil + fake.creatorReturns = struct { + result1 view.Identity + }{result1} +} + +func (fake *FabricTransaction) CreatorReturnsOnCall(i int, result1 view.Identity) { + fake.creatorMutex.Lock() + defer fake.creatorMutex.Unlock() + fake.CreatorStub = nil + if fake.creatorReturnsOnCall == nil { + fake.creatorReturnsOnCall = make(map[int]struct { + result1 view.Identity + }) + } + fake.creatorReturnsOnCall[i] = struct { + result1 view.Identity + }{result1} +} + +func (fake *FabricTransaction) Done() error { + fake.doneMutex.Lock() + ret, specificReturn := fake.doneReturnsOnCall[len(fake.doneArgsForCall)] + fake.doneArgsForCall = append(fake.doneArgsForCall, struct { + }{}) + stub := fake.DoneStub + fakeReturns := fake.doneReturns + fake.recordInvocation("Done", []interface{}{}) + fake.doneMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) DoneCallCount() int { + fake.doneMutex.RLock() + defer fake.doneMutex.RUnlock() + return len(fake.doneArgsForCall) +} + +func (fake *FabricTransaction) DoneCalls(stub func() error) { + fake.doneMutex.Lock() + defer fake.doneMutex.Unlock() + fake.DoneStub = stub +} + +func (fake *FabricTransaction) DoneReturns(result1 error) { + fake.doneMutex.Lock() + defer fake.doneMutex.Unlock() + fake.DoneStub = nil + fake.doneReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) DoneReturnsOnCall(i int, result1 error) { + fake.doneMutex.Lock() + defer fake.doneMutex.Unlock() + fake.DoneStub = nil + if fake.doneReturnsOnCall == nil { + fake.doneReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.doneReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) Endorse() error { + fake.endorseMutex.Lock() + ret, specificReturn := fake.endorseReturnsOnCall[len(fake.endorseArgsForCall)] + fake.endorseArgsForCall = append(fake.endorseArgsForCall, struct { + }{}) + stub := fake.EndorseStub + fakeReturns := fake.endorseReturns + fake.recordInvocation("Endorse", []interface{}{}) + fake.endorseMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) EndorseCallCount() int { + fake.endorseMutex.RLock() + defer fake.endorseMutex.RUnlock() + return len(fake.endorseArgsForCall) +} + +func (fake *FabricTransaction) EndorseCalls(stub func() error) { + fake.endorseMutex.Lock() + defer fake.endorseMutex.Unlock() + fake.EndorseStub = stub +} + +func (fake *FabricTransaction) EndorseReturns(result1 error) { + fake.endorseMutex.Lock() + defer fake.endorseMutex.Unlock() + fake.EndorseStub = nil + fake.endorseReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseReturnsOnCall(i int, result1 error) { + fake.endorseMutex.Lock() + defer fake.endorseMutex.Unlock() + fake.EndorseStub = nil + if fake.endorseReturnsOnCall == nil { + fake.endorseReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.endorseReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseProposal() error { + fake.endorseProposalMutex.Lock() + ret, specificReturn := fake.endorseProposalReturnsOnCall[len(fake.endorseProposalArgsForCall)] + fake.endorseProposalArgsForCall = append(fake.endorseProposalArgsForCall, struct { + }{}) + stub := fake.EndorseProposalStub + fakeReturns := fake.endorseProposalReturns + fake.recordInvocation("EndorseProposal", []interface{}{}) + fake.endorseProposalMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) EndorseProposalCallCount() int { + fake.endorseProposalMutex.RLock() + defer fake.endorseProposalMutex.RUnlock() + return len(fake.endorseProposalArgsForCall) +} + +func (fake *FabricTransaction) EndorseProposalCalls(stub func() error) { + fake.endorseProposalMutex.Lock() + defer fake.endorseProposalMutex.Unlock() + fake.EndorseProposalStub = stub +} + +func (fake *FabricTransaction) EndorseProposalReturns(result1 error) { + fake.endorseProposalMutex.Lock() + defer fake.endorseProposalMutex.Unlock() + fake.EndorseProposalStub = nil + fake.endorseProposalReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseProposalReturnsOnCall(i int, result1 error) { + fake.endorseProposalMutex.Lock() + defer fake.endorseProposalMutex.Unlock() + fake.EndorseProposalStub = nil + if fake.endorseProposalReturnsOnCall == nil { + fake.endorseProposalReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.endorseProposalReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseProposalResponse() error { + fake.endorseProposalResponseMutex.Lock() + ret, specificReturn := fake.endorseProposalResponseReturnsOnCall[len(fake.endorseProposalResponseArgsForCall)] + fake.endorseProposalResponseArgsForCall = append(fake.endorseProposalResponseArgsForCall, struct { + }{}) + stub := fake.EndorseProposalResponseStub + fakeReturns := fake.endorseProposalResponseReturns + fake.recordInvocation("EndorseProposalResponse", []interface{}{}) + fake.endorseProposalResponseMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) EndorseProposalResponseCallCount() int { + fake.endorseProposalResponseMutex.RLock() + defer fake.endorseProposalResponseMutex.RUnlock() + return len(fake.endorseProposalResponseArgsForCall) +} + +func (fake *FabricTransaction) EndorseProposalResponseCalls(stub func() error) { + fake.endorseProposalResponseMutex.Lock() + defer fake.endorseProposalResponseMutex.Unlock() + fake.EndorseProposalResponseStub = stub +} + +func (fake *FabricTransaction) EndorseProposalResponseReturns(result1 error) { + fake.endorseProposalResponseMutex.Lock() + defer fake.endorseProposalResponseMutex.Unlock() + fake.EndorseProposalResponseStub = nil + fake.endorseProposalResponseReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseProposalResponseReturnsOnCall(i int, result1 error) { + fake.endorseProposalResponseMutex.Lock() + defer fake.endorseProposalResponseMutex.Unlock() + fake.EndorseProposalResponseStub = nil + if fake.endorseProposalResponseReturnsOnCall == nil { + fake.endorseProposalResponseReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.endorseProposalResponseReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseProposalResponseWithIdentity(arg1 view.Identity) error { + fake.endorseProposalResponseWithIdentityMutex.Lock() + ret, specificReturn := fake.endorseProposalResponseWithIdentityReturnsOnCall[len(fake.endorseProposalResponseWithIdentityArgsForCall)] + fake.endorseProposalResponseWithIdentityArgsForCall = append(fake.endorseProposalResponseWithIdentityArgsForCall, struct { + arg1 view.Identity + }{arg1}) + stub := fake.EndorseProposalResponseWithIdentityStub + fakeReturns := fake.endorseProposalResponseWithIdentityReturns + fake.recordInvocation("EndorseProposalResponseWithIdentity", []interface{}{arg1}) + fake.endorseProposalResponseWithIdentityMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) EndorseProposalResponseWithIdentityCallCount() int { + fake.endorseProposalResponseWithIdentityMutex.RLock() + defer fake.endorseProposalResponseWithIdentityMutex.RUnlock() + return len(fake.endorseProposalResponseWithIdentityArgsForCall) +} + +func (fake *FabricTransaction) EndorseProposalResponseWithIdentityCalls(stub func(view.Identity) error) { + fake.endorseProposalResponseWithIdentityMutex.Lock() + defer fake.endorseProposalResponseWithIdentityMutex.Unlock() + fake.EndorseProposalResponseWithIdentityStub = stub +} + +func (fake *FabricTransaction) EndorseProposalResponseWithIdentityArgsForCall(i int) view.Identity { + fake.endorseProposalResponseWithIdentityMutex.RLock() + defer fake.endorseProposalResponseWithIdentityMutex.RUnlock() + argsForCall := fake.endorseProposalResponseWithIdentityArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricTransaction) EndorseProposalResponseWithIdentityReturns(result1 error) { + fake.endorseProposalResponseWithIdentityMutex.Lock() + defer fake.endorseProposalResponseWithIdentityMutex.Unlock() + fake.EndorseProposalResponseWithIdentityStub = nil + fake.endorseProposalResponseWithIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseProposalResponseWithIdentityReturnsOnCall(i int, result1 error) { + fake.endorseProposalResponseWithIdentityMutex.Lock() + defer fake.endorseProposalResponseWithIdentityMutex.Unlock() + fake.EndorseProposalResponseWithIdentityStub = nil + if fake.endorseProposalResponseWithIdentityReturnsOnCall == nil { + fake.endorseProposalResponseWithIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.endorseProposalResponseWithIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseProposalWithIdentity(arg1 view.Identity) error { + fake.endorseProposalWithIdentityMutex.Lock() + ret, specificReturn := fake.endorseProposalWithIdentityReturnsOnCall[len(fake.endorseProposalWithIdentityArgsForCall)] + fake.endorseProposalWithIdentityArgsForCall = append(fake.endorseProposalWithIdentityArgsForCall, struct { + arg1 view.Identity + }{arg1}) + stub := fake.EndorseProposalWithIdentityStub + fakeReturns := fake.endorseProposalWithIdentityReturns + fake.recordInvocation("EndorseProposalWithIdentity", []interface{}{arg1}) + fake.endorseProposalWithIdentityMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) EndorseProposalWithIdentityCallCount() int { + fake.endorseProposalWithIdentityMutex.RLock() + defer fake.endorseProposalWithIdentityMutex.RUnlock() + return len(fake.endorseProposalWithIdentityArgsForCall) +} + +func (fake *FabricTransaction) EndorseProposalWithIdentityCalls(stub func(view.Identity) error) { + fake.endorseProposalWithIdentityMutex.Lock() + defer fake.endorseProposalWithIdentityMutex.Unlock() + fake.EndorseProposalWithIdentityStub = stub +} + +func (fake *FabricTransaction) EndorseProposalWithIdentityArgsForCall(i int) view.Identity { + fake.endorseProposalWithIdentityMutex.RLock() + defer fake.endorseProposalWithIdentityMutex.RUnlock() + argsForCall := fake.endorseProposalWithIdentityArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricTransaction) EndorseProposalWithIdentityReturns(result1 error) { + fake.endorseProposalWithIdentityMutex.Lock() + defer fake.endorseProposalWithIdentityMutex.Unlock() + fake.EndorseProposalWithIdentityStub = nil + fake.endorseProposalWithIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseProposalWithIdentityReturnsOnCall(i int, result1 error) { + fake.endorseProposalWithIdentityMutex.Lock() + defer fake.endorseProposalWithIdentityMutex.Unlock() + fake.EndorseProposalWithIdentityStub = nil + if fake.endorseProposalWithIdentityReturnsOnCall == nil { + fake.endorseProposalWithIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.endorseProposalWithIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseWithIdentity(arg1 view.Identity) error { + fake.endorseWithIdentityMutex.Lock() + ret, specificReturn := fake.endorseWithIdentityReturnsOnCall[len(fake.endorseWithIdentityArgsForCall)] + fake.endorseWithIdentityArgsForCall = append(fake.endorseWithIdentityArgsForCall, struct { + arg1 view.Identity + }{arg1}) + stub := fake.EndorseWithIdentityStub + fakeReturns := fake.endorseWithIdentityReturns + fake.recordInvocation("EndorseWithIdentity", []interface{}{arg1}) + fake.endorseWithIdentityMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) EndorseWithIdentityCallCount() int { + fake.endorseWithIdentityMutex.RLock() + defer fake.endorseWithIdentityMutex.RUnlock() + return len(fake.endorseWithIdentityArgsForCall) +} + +func (fake *FabricTransaction) EndorseWithIdentityCalls(stub func(view.Identity) error) { + fake.endorseWithIdentityMutex.Lock() + defer fake.endorseWithIdentityMutex.Unlock() + fake.EndorseWithIdentityStub = stub +} + +func (fake *FabricTransaction) EndorseWithIdentityArgsForCall(i int) view.Identity { + fake.endorseWithIdentityMutex.RLock() + defer fake.endorseWithIdentityMutex.RUnlock() + argsForCall := fake.endorseWithIdentityArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricTransaction) EndorseWithIdentityReturns(result1 error) { + fake.endorseWithIdentityMutex.Lock() + defer fake.endorseWithIdentityMutex.Unlock() + fake.EndorseWithIdentityStub = nil + fake.endorseWithIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseWithIdentityReturnsOnCall(i int, result1 error) { + fake.endorseWithIdentityMutex.Lock() + defer fake.endorseWithIdentityMutex.Unlock() + fake.EndorseWithIdentityStub = nil + if fake.endorseWithIdentityReturnsOnCall == nil { + fake.endorseWithIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.endorseWithIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseWithSigner(arg1 view.Identity, arg2 driver.Signer) error { + fake.endorseWithSignerMutex.Lock() + ret, specificReturn := fake.endorseWithSignerReturnsOnCall[len(fake.endorseWithSignerArgsForCall)] + fake.endorseWithSignerArgsForCall = append(fake.endorseWithSignerArgsForCall, struct { + arg1 view.Identity + arg2 driver.Signer + }{arg1, arg2}) + stub := fake.EndorseWithSignerStub + fakeReturns := fake.endorseWithSignerReturns + fake.recordInvocation("EndorseWithSigner", []interface{}{arg1, arg2}) + fake.endorseWithSignerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) EndorseWithSignerCallCount() int { + fake.endorseWithSignerMutex.RLock() + defer fake.endorseWithSignerMutex.RUnlock() + return len(fake.endorseWithSignerArgsForCall) +} + +func (fake *FabricTransaction) EndorseWithSignerCalls(stub func(view.Identity, driver.Signer) error) { + fake.endorseWithSignerMutex.Lock() + defer fake.endorseWithSignerMutex.Unlock() + fake.EndorseWithSignerStub = stub +} + +func (fake *FabricTransaction) EndorseWithSignerArgsForCall(i int) (view.Identity, driver.Signer) { + fake.endorseWithSignerMutex.RLock() + defer fake.endorseWithSignerMutex.RUnlock() + argsForCall := fake.endorseWithSignerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FabricTransaction) EndorseWithSignerReturns(result1 error) { + fake.endorseWithSignerMutex.Lock() + defer fake.endorseWithSignerMutex.Unlock() + fake.EndorseWithSignerStub = nil + fake.endorseWithSignerReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) EndorseWithSignerReturnsOnCall(i int, result1 error) { + fake.endorseWithSignerMutex.Lock() + defer fake.endorseWithSignerMutex.Unlock() + fake.EndorseWithSignerStub = nil + if fake.endorseWithSignerReturnsOnCall == nil { + fake.endorseWithSignerReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.endorseWithSignerReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) Envelope() (driver.Envelope, error) { + fake.envelopeMutex.Lock() + ret, specificReturn := fake.envelopeReturnsOnCall[len(fake.envelopeArgsForCall)] + fake.envelopeArgsForCall = append(fake.envelopeArgsForCall, struct { + }{}) + stub := fake.EnvelopeStub + fakeReturns := fake.envelopeReturns + fake.recordInvocation("Envelope", []interface{}{}) + fake.envelopeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricTransaction) EnvelopeCallCount() int { + fake.envelopeMutex.RLock() + defer fake.envelopeMutex.RUnlock() + return len(fake.envelopeArgsForCall) +} + +func (fake *FabricTransaction) EnvelopeCalls(stub func() (driver.Envelope, error)) { + fake.envelopeMutex.Lock() + defer fake.envelopeMutex.Unlock() + fake.EnvelopeStub = stub +} + +func (fake *FabricTransaction) EnvelopeReturns(result1 driver.Envelope, result2 error) { + fake.envelopeMutex.Lock() + defer fake.envelopeMutex.Unlock() + fake.EnvelopeStub = nil + fake.envelopeReturns = struct { + result1 driver.Envelope + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) EnvelopeReturnsOnCall(i int, result1 driver.Envelope, result2 error) { + fake.envelopeMutex.Lock() + defer fake.envelopeMutex.Unlock() + fake.EnvelopeStub = nil + if fake.envelopeReturnsOnCall == nil { + fake.envelopeReturnsOnCall = make(map[int]struct { + result1 driver.Envelope + result2 error + }) + } + fake.envelopeReturnsOnCall[i] = struct { + result1 driver.Envelope + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) From(arg1 driver.Transaction) error { + fake.fromMutex.Lock() + ret, specificReturn := fake.fromReturnsOnCall[len(fake.fromArgsForCall)] + fake.fromArgsForCall = append(fake.fromArgsForCall, struct { + arg1 driver.Transaction + }{arg1}) + stub := fake.FromStub + fakeReturns := fake.fromReturns + fake.recordInvocation("From", []interface{}{arg1}) + fake.fromMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) FromCallCount() int { + fake.fromMutex.RLock() + defer fake.fromMutex.RUnlock() + return len(fake.fromArgsForCall) +} + +func (fake *FabricTransaction) FromCalls(stub func(driver.Transaction) error) { + fake.fromMutex.Lock() + defer fake.fromMutex.Unlock() + fake.FromStub = stub +} + +func (fake *FabricTransaction) FromArgsForCall(i int) driver.Transaction { + fake.fromMutex.RLock() + defer fake.fromMutex.RUnlock() + argsForCall := fake.fromArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricTransaction) FromReturns(result1 error) { + fake.fromMutex.Lock() + defer fake.fromMutex.Unlock() + fake.FromStub = nil + fake.fromReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) FromReturnsOnCall(i int, result1 error) { + fake.fromMutex.Lock() + defer fake.fromMutex.Unlock() + fake.FromStub = nil + if fake.fromReturnsOnCall == nil { + fake.fromReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.fromReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) Function() string { + fake.functionMutex.Lock() + ret, specificReturn := fake.functionReturnsOnCall[len(fake.functionArgsForCall)] + fake.functionArgsForCall = append(fake.functionArgsForCall, struct { + }{}) + stub := fake.FunctionStub + fakeReturns := fake.functionReturns + fake.recordInvocation("Function", []interface{}{}) + fake.functionMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) FunctionCallCount() int { + fake.functionMutex.RLock() + defer fake.functionMutex.RUnlock() + return len(fake.functionArgsForCall) +} + +func (fake *FabricTransaction) FunctionCalls(stub func() string) { + fake.functionMutex.Lock() + defer fake.functionMutex.Unlock() + fake.FunctionStub = stub +} + +func (fake *FabricTransaction) FunctionReturns(result1 string) { + fake.functionMutex.Lock() + defer fake.functionMutex.Unlock() + fake.FunctionStub = nil + fake.functionReturns = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) FunctionReturnsOnCall(i int, result1 string) { + fake.functionMutex.Lock() + defer fake.functionMutex.Unlock() + fake.FunctionStub = nil + if fake.functionReturnsOnCall == nil { + fake.functionReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.functionReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) FunctionAndParameters() (string, []string) { + fake.functionAndParametersMutex.Lock() + ret, specificReturn := fake.functionAndParametersReturnsOnCall[len(fake.functionAndParametersArgsForCall)] + fake.functionAndParametersArgsForCall = append(fake.functionAndParametersArgsForCall, struct { + }{}) + stub := fake.FunctionAndParametersStub + fakeReturns := fake.functionAndParametersReturns + fake.recordInvocation("FunctionAndParameters", []interface{}{}) + fake.functionAndParametersMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricTransaction) FunctionAndParametersCallCount() int { + fake.functionAndParametersMutex.RLock() + defer fake.functionAndParametersMutex.RUnlock() + return len(fake.functionAndParametersArgsForCall) +} + +func (fake *FabricTransaction) FunctionAndParametersCalls(stub func() (string, []string)) { + fake.functionAndParametersMutex.Lock() + defer fake.functionAndParametersMutex.Unlock() + fake.FunctionAndParametersStub = stub +} + +func (fake *FabricTransaction) FunctionAndParametersReturns(result1 string, result2 []string) { + fake.functionAndParametersMutex.Lock() + defer fake.functionAndParametersMutex.Unlock() + fake.FunctionAndParametersStub = nil + fake.functionAndParametersReturns = struct { + result1 string + result2 []string + }{result1, result2} +} + +func (fake *FabricTransaction) FunctionAndParametersReturnsOnCall(i int, result1 string, result2 []string) { + fake.functionAndParametersMutex.Lock() + defer fake.functionAndParametersMutex.Unlock() + fake.FunctionAndParametersStub = nil + if fake.functionAndParametersReturnsOnCall == nil { + fake.functionAndParametersReturnsOnCall = make(map[int]struct { + result1 string + result2 []string + }) + } + fake.functionAndParametersReturnsOnCall[i] = struct { + result1 string + result2 []string + }{result1, result2} +} + +func (fake *FabricTransaction) GetRWSet() (driver.RWSet, error) { + fake.getRWSetMutex.Lock() + ret, specificReturn := fake.getRWSetReturnsOnCall[len(fake.getRWSetArgsForCall)] + fake.getRWSetArgsForCall = append(fake.getRWSetArgsForCall, struct { + }{}) + stub := fake.GetRWSetStub + fakeReturns := fake.getRWSetReturns + fake.recordInvocation("GetRWSet", []interface{}{}) + fake.getRWSetMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricTransaction) GetRWSetCallCount() int { + fake.getRWSetMutex.RLock() + defer fake.getRWSetMutex.RUnlock() + return len(fake.getRWSetArgsForCall) +} + +func (fake *FabricTransaction) GetRWSetCalls(stub func() (driver.RWSet, error)) { + fake.getRWSetMutex.Lock() + defer fake.getRWSetMutex.Unlock() + fake.GetRWSetStub = stub +} + +func (fake *FabricTransaction) GetRWSetReturns(result1 driver.RWSet, result2 error) { + fake.getRWSetMutex.Lock() + defer fake.getRWSetMutex.Unlock() + fake.GetRWSetStub = nil + fake.getRWSetReturns = struct { + result1 driver.RWSet + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) GetRWSetReturnsOnCall(i int, result1 driver.RWSet, result2 error) { + fake.getRWSetMutex.Lock() + defer fake.getRWSetMutex.Unlock() + fake.GetRWSetStub = nil + if fake.getRWSetReturnsOnCall == nil { + fake.getRWSetReturnsOnCall = make(map[int]struct { + result1 driver.RWSet + result2 error + }) + } + fake.getRWSetReturnsOnCall[i] = struct { + result1 driver.RWSet + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) ID() string { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *FabricTransaction) IDCalls(stub func() string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *FabricTransaction) IDReturns(result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) IDReturnsOnCall(i int, result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) Network() string { + fake.networkMutex.Lock() + ret, specificReturn := fake.networkReturnsOnCall[len(fake.networkArgsForCall)] + fake.networkArgsForCall = append(fake.networkArgsForCall, struct { + }{}) + stub := fake.NetworkStub + fakeReturns := fake.networkReturns + fake.recordInvocation("Network", []interface{}{}) + fake.networkMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) NetworkCallCount() int { + fake.networkMutex.RLock() + defer fake.networkMutex.RUnlock() + return len(fake.networkArgsForCall) +} + +func (fake *FabricTransaction) NetworkCalls(stub func() string) { + fake.networkMutex.Lock() + defer fake.networkMutex.Unlock() + fake.NetworkStub = stub +} + +func (fake *FabricTransaction) NetworkReturns(result1 string) { + fake.networkMutex.Lock() + defer fake.networkMutex.Unlock() + fake.NetworkStub = nil + fake.networkReturns = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) NetworkReturnsOnCall(i int, result1 string) { + fake.networkMutex.Lock() + defer fake.networkMutex.Unlock() + fake.NetworkStub = nil + if fake.networkReturnsOnCall == nil { + fake.networkReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.networkReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FabricTransaction) Nonce() []byte { + fake.nonceMutex.Lock() + ret, specificReturn := fake.nonceReturnsOnCall[len(fake.nonceArgsForCall)] + fake.nonceArgsForCall = append(fake.nonceArgsForCall, struct { + }{}) + stub := fake.NonceStub + fakeReturns := fake.nonceReturns + fake.recordInvocation("Nonce", []interface{}{}) + fake.nonceMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) NonceCallCount() int { + fake.nonceMutex.RLock() + defer fake.nonceMutex.RUnlock() + return len(fake.nonceArgsForCall) +} + +func (fake *FabricTransaction) NonceCalls(stub func() []byte) { + fake.nonceMutex.Lock() + defer fake.nonceMutex.Unlock() + fake.NonceStub = stub +} + +func (fake *FabricTransaction) NonceReturns(result1 []byte) { + fake.nonceMutex.Lock() + defer fake.nonceMutex.Unlock() + fake.NonceStub = nil + fake.nonceReturns = struct { + result1 []byte + }{result1} +} + +func (fake *FabricTransaction) NonceReturnsOnCall(i int, result1 []byte) { + fake.nonceMutex.Lock() + defer fake.nonceMutex.Unlock() + fake.NonceStub = nil + if fake.nonceReturnsOnCall == nil { + fake.nonceReturnsOnCall = make(map[int]struct { + result1 []byte + }) + } + fake.nonceReturnsOnCall[i] = struct { + result1 []byte + }{result1} +} + +func (fake *FabricTransaction) Parameters() [][]byte { + fake.parametersMutex.Lock() + ret, specificReturn := fake.parametersReturnsOnCall[len(fake.parametersArgsForCall)] + fake.parametersArgsForCall = append(fake.parametersArgsForCall, struct { + }{}) + stub := fake.ParametersStub + fakeReturns := fake.parametersReturns + fake.recordInvocation("Parameters", []interface{}{}) + fake.parametersMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) ParametersCallCount() int { + fake.parametersMutex.RLock() + defer fake.parametersMutex.RUnlock() + return len(fake.parametersArgsForCall) +} + +func (fake *FabricTransaction) ParametersCalls(stub func() [][]byte) { + fake.parametersMutex.Lock() + defer fake.parametersMutex.Unlock() + fake.ParametersStub = stub +} + +func (fake *FabricTransaction) ParametersReturns(result1 [][]byte) { + fake.parametersMutex.Lock() + defer fake.parametersMutex.Unlock() + fake.ParametersStub = nil + fake.parametersReturns = struct { + result1 [][]byte + }{result1} +} + +func (fake *FabricTransaction) ParametersReturnsOnCall(i int, result1 [][]byte) { + fake.parametersMutex.Lock() + defer fake.parametersMutex.Unlock() + fake.ParametersStub = nil + if fake.parametersReturnsOnCall == nil { + fake.parametersReturnsOnCall = make(map[int]struct { + result1 [][]byte + }) + } + fake.parametersReturnsOnCall[i] = struct { + result1 [][]byte + }{result1} +} + +func (fake *FabricTransaction) Proposal() driver.Proposal { + fake.proposalMutex.Lock() + ret, specificReturn := fake.proposalReturnsOnCall[len(fake.proposalArgsForCall)] + fake.proposalArgsForCall = append(fake.proposalArgsForCall, struct { + }{}) + stub := fake.ProposalStub + fakeReturns := fake.proposalReturns + fake.recordInvocation("Proposal", []interface{}{}) + fake.proposalMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) ProposalCallCount() int { + fake.proposalMutex.RLock() + defer fake.proposalMutex.RUnlock() + return len(fake.proposalArgsForCall) +} + +func (fake *FabricTransaction) ProposalCalls(stub func() driver.Proposal) { + fake.proposalMutex.Lock() + defer fake.proposalMutex.Unlock() + fake.ProposalStub = stub +} + +func (fake *FabricTransaction) ProposalReturns(result1 driver.Proposal) { + fake.proposalMutex.Lock() + defer fake.proposalMutex.Unlock() + fake.ProposalStub = nil + fake.proposalReturns = struct { + result1 driver.Proposal + }{result1} +} + +func (fake *FabricTransaction) ProposalReturnsOnCall(i int, result1 driver.Proposal) { + fake.proposalMutex.Lock() + defer fake.proposalMutex.Unlock() + fake.ProposalStub = nil + if fake.proposalReturnsOnCall == nil { + fake.proposalReturnsOnCall = make(map[int]struct { + result1 driver.Proposal + }) + } + fake.proposalReturnsOnCall[i] = struct { + result1 driver.Proposal + }{result1} +} + +func (fake *FabricTransaction) ProposalHasBeenEndorsedBy(arg1 view.Identity) error { + fake.proposalHasBeenEndorsedByMutex.Lock() + ret, specificReturn := fake.proposalHasBeenEndorsedByReturnsOnCall[len(fake.proposalHasBeenEndorsedByArgsForCall)] + fake.proposalHasBeenEndorsedByArgsForCall = append(fake.proposalHasBeenEndorsedByArgsForCall, struct { + arg1 view.Identity + }{arg1}) + stub := fake.ProposalHasBeenEndorsedByStub + fakeReturns := fake.proposalHasBeenEndorsedByReturns + fake.recordInvocation("ProposalHasBeenEndorsedBy", []interface{}{arg1}) + fake.proposalHasBeenEndorsedByMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) ProposalHasBeenEndorsedByCallCount() int { + fake.proposalHasBeenEndorsedByMutex.RLock() + defer fake.proposalHasBeenEndorsedByMutex.RUnlock() + return len(fake.proposalHasBeenEndorsedByArgsForCall) +} + +func (fake *FabricTransaction) ProposalHasBeenEndorsedByCalls(stub func(view.Identity) error) { + fake.proposalHasBeenEndorsedByMutex.Lock() + defer fake.proposalHasBeenEndorsedByMutex.Unlock() + fake.ProposalHasBeenEndorsedByStub = stub +} + +func (fake *FabricTransaction) ProposalHasBeenEndorsedByArgsForCall(i int) view.Identity { + fake.proposalHasBeenEndorsedByMutex.RLock() + defer fake.proposalHasBeenEndorsedByMutex.RUnlock() + argsForCall := fake.proposalHasBeenEndorsedByArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricTransaction) ProposalHasBeenEndorsedByReturns(result1 error) { + fake.proposalHasBeenEndorsedByMutex.Lock() + defer fake.proposalHasBeenEndorsedByMutex.Unlock() + fake.ProposalHasBeenEndorsedByStub = nil + fake.proposalHasBeenEndorsedByReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) ProposalHasBeenEndorsedByReturnsOnCall(i int, result1 error) { + fake.proposalHasBeenEndorsedByMutex.Lock() + defer fake.proposalHasBeenEndorsedByMutex.Unlock() + fake.ProposalHasBeenEndorsedByStub = nil + if fake.proposalHasBeenEndorsedByReturnsOnCall == nil { + fake.proposalHasBeenEndorsedByReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.proposalHasBeenEndorsedByReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) ProposalResponse() ([]byte, error) { + fake.proposalResponseMutex.Lock() + ret, specificReturn := fake.proposalResponseReturnsOnCall[len(fake.proposalResponseArgsForCall)] + fake.proposalResponseArgsForCall = append(fake.proposalResponseArgsForCall, struct { + }{}) + stub := fake.ProposalResponseStub + fakeReturns := fake.proposalResponseReturns + fake.recordInvocation("ProposalResponse", []interface{}{}) + fake.proposalResponseMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricTransaction) ProposalResponseCallCount() int { + fake.proposalResponseMutex.RLock() + defer fake.proposalResponseMutex.RUnlock() + return len(fake.proposalResponseArgsForCall) +} + +func (fake *FabricTransaction) ProposalResponseCalls(stub func() ([]byte, error)) { + fake.proposalResponseMutex.Lock() + defer fake.proposalResponseMutex.Unlock() + fake.ProposalResponseStub = stub +} + +func (fake *FabricTransaction) ProposalResponseReturns(result1 []byte, result2 error) { + fake.proposalResponseMutex.Lock() + defer fake.proposalResponseMutex.Unlock() + fake.ProposalResponseStub = nil + fake.proposalResponseReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) ProposalResponseReturnsOnCall(i int, result1 []byte, result2 error) { + fake.proposalResponseMutex.Lock() + defer fake.proposalResponseMutex.Unlock() + fake.ProposalResponseStub = nil + if fake.proposalResponseReturnsOnCall == nil { + fake.proposalResponseReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.proposalResponseReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) ProposalResponses() ([]driver.ProposalResponse, error) { + fake.proposalResponsesMutex.Lock() + ret, specificReturn := fake.proposalResponsesReturnsOnCall[len(fake.proposalResponsesArgsForCall)] + fake.proposalResponsesArgsForCall = append(fake.proposalResponsesArgsForCall, struct { + }{}) + stub := fake.ProposalResponsesStub + fakeReturns := fake.proposalResponsesReturns + fake.recordInvocation("ProposalResponses", []interface{}{}) + fake.proposalResponsesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricTransaction) ProposalResponsesCallCount() int { + fake.proposalResponsesMutex.RLock() + defer fake.proposalResponsesMutex.RUnlock() + return len(fake.proposalResponsesArgsForCall) +} + +func (fake *FabricTransaction) ProposalResponsesCalls(stub func() ([]driver.ProposalResponse, error)) { + fake.proposalResponsesMutex.Lock() + defer fake.proposalResponsesMutex.Unlock() + fake.ProposalResponsesStub = stub +} + +func (fake *FabricTransaction) ProposalResponsesReturns(result1 []driver.ProposalResponse, result2 error) { + fake.proposalResponsesMutex.Lock() + defer fake.proposalResponsesMutex.Unlock() + fake.ProposalResponsesStub = nil + fake.proposalResponsesReturns = struct { + result1 []driver.ProposalResponse + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) ProposalResponsesReturnsOnCall(i int, result1 []driver.ProposalResponse, result2 error) { + fake.proposalResponsesMutex.Lock() + defer fake.proposalResponsesMutex.Unlock() + fake.ProposalResponsesStub = nil + if fake.proposalResponsesReturnsOnCall == nil { + fake.proposalResponsesReturnsOnCall = make(map[int]struct { + result1 []driver.ProposalResponse + result2 error + }) + } + fake.proposalResponsesReturnsOnCall[i] = struct { + result1 []driver.ProposalResponse + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) RWS() driver.RWSet { + fake.rWSMutex.Lock() + ret, specificReturn := fake.rWSReturnsOnCall[len(fake.rWSArgsForCall)] + fake.rWSArgsForCall = append(fake.rWSArgsForCall, struct { + }{}) + stub := fake.RWSStub + fakeReturns := fake.rWSReturns + fake.recordInvocation("RWS", []interface{}{}) + fake.rWSMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) RWSCallCount() int { + fake.rWSMutex.RLock() + defer fake.rWSMutex.RUnlock() + return len(fake.rWSArgsForCall) +} + +func (fake *FabricTransaction) RWSCalls(stub func() driver.RWSet) { + fake.rWSMutex.Lock() + defer fake.rWSMutex.Unlock() + fake.RWSStub = stub +} + +func (fake *FabricTransaction) RWSReturns(result1 driver.RWSet) { + fake.rWSMutex.Lock() + defer fake.rWSMutex.Unlock() + fake.RWSStub = nil + fake.rWSReturns = struct { + result1 driver.RWSet + }{result1} +} + +func (fake *FabricTransaction) RWSReturnsOnCall(i int, result1 driver.RWSet) { + fake.rWSMutex.Lock() + defer fake.rWSMutex.Unlock() + fake.RWSStub = nil + if fake.rWSReturnsOnCall == nil { + fake.rWSReturnsOnCall = make(map[int]struct { + result1 driver.RWSet + }) + } + fake.rWSReturnsOnCall[i] = struct { + result1 driver.RWSet + }{result1} +} + +func (fake *FabricTransaction) Raw() ([]byte, error) { + fake.rawMutex.Lock() + ret, specificReturn := fake.rawReturnsOnCall[len(fake.rawArgsForCall)] + fake.rawArgsForCall = append(fake.rawArgsForCall, struct { + }{}) + stub := fake.RawStub + fakeReturns := fake.rawReturns + fake.recordInvocation("Raw", []interface{}{}) + fake.rawMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricTransaction) RawCallCount() int { + fake.rawMutex.RLock() + defer fake.rawMutex.RUnlock() + return len(fake.rawArgsForCall) +} + +func (fake *FabricTransaction) RawCalls(stub func() ([]byte, error)) { + fake.rawMutex.Lock() + defer fake.rawMutex.Unlock() + fake.RawStub = stub +} + +func (fake *FabricTransaction) RawReturns(result1 []byte, result2 error) { + fake.rawMutex.Lock() + defer fake.rawMutex.Unlock() + fake.RawStub = nil + fake.rawReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) RawReturnsOnCall(i int, result1 []byte, result2 error) { + fake.rawMutex.Lock() + defer fake.rawMutex.Unlock() + fake.RawStub = nil + if fake.rawReturnsOnCall == nil { + fake.rawReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.rawReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) ResetTransient() { + fake.resetTransientMutex.Lock() + fake.resetTransientArgsForCall = append(fake.resetTransientArgsForCall, struct { + }{}) + stub := fake.ResetTransientStub + fake.recordInvocation("ResetTransient", []interface{}{}) + fake.resetTransientMutex.Unlock() + if stub != nil { + fake.ResetTransientStub() + } +} + +func (fake *FabricTransaction) ResetTransientCallCount() int { + fake.resetTransientMutex.RLock() + defer fake.resetTransientMutex.RUnlock() + return len(fake.resetTransientArgsForCall) +} + +func (fake *FabricTransaction) ResetTransientCalls(stub func()) { + fake.resetTransientMutex.Lock() + defer fake.resetTransientMutex.Unlock() + fake.ResetTransientStub = stub +} + +func (fake *FabricTransaction) Results() ([]byte, error) { + fake.resultsMutex.Lock() + ret, specificReturn := fake.resultsReturnsOnCall[len(fake.resultsArgsForCall)] + fake.resultsArgsForCall = append(fake.resultsArgsForCall, struct { + }{}) + stub := fake.ResultsStub + fakeReturns := fake.resultsReturns + fake.recordInvocation("Results", []interface{}{}) + fake.resultsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FabricTransaction) ResultsCallCount() int { + fake.resultsMutex.RLock() + defer fake.resultsMutex.RUnlock() + return len(fake.resultsArgsForCall) +} + +func (fake *FabricTransaction) ResultsCalls(stub func() ([]byte, error)) { + fake.resultsMutex.Lock() + defer fake.resultsMutex.Unlock() + fake.ResultsStub = stub +} + +func (fake *FabricTransaction) ResultsReturns(result1 []byte, result2 error) { + fake.resultsMutex.Lock() + defer fake.resultsMutex.Unlock() + fake.ResultsStub = nil + fake.resultsReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) ResultsReturnsOnCall(i int, result1 []byte, result2 error) { + fake.resultsMutex.Lock() + defer fake.resultsMutex.Unlock() + fake.ResultsStub = nil + if fake.resultsReturnsOnCall == nil { + fake.resultsReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.resultsReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *FabricTransaction) SetFromBytes(arg1 []byte) error { + var arg1Copy []byte + if arg1 != nil { + arg1Copy = make([]byte, len(arg1)) + copy(arg1Copy, arg1) + } + fake.setFromBytesMutex.Lock() + ret, specificReturn := fake.setFromBytesReturnsOnCall[len(fake.setFromBytesArgsForCall)] + fake.setFromBytesArgsForCall = append(fake.setFromBytesArgsForCall, struct { + arg1 []byte + }{arg1Copy}) + stub := fake.SetFromBytesStub + fakeReturns := fake.setFromBytesReturns + fake.recordInvocation("SetFromBytes", []interface{}{arg1Copy}) + fake.setFromBytesMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) SetFromBytesCallCount() int { + fake.setFromBytesMutex.RLock() + defer fake.setFromBytesMutex.RUnlock() + return len(fake.setFromBytesArgsForCall) +} + +func (fake *FabricTransaction) SetFromBytesCalls(stub func([]byte) error) { + fake.setFromBytesMutex.Lock() + defer fake.setFromBytesMutex.Unlock() + fake.SetFromBytesStub = stub +} + +func (fake *FabricTransaction) SetFromBytesArgsForCall(i int) []byte { + fake.setFromBytesMutex.RLock() + defer fake.setFromBytesMutex.RUnlock() + argsForCall := fake.setFromBytesArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricTransaction) SetFromBytesReturns(result1 error) { + fake.setFromBytesMutex.Lock() + defer fake.setFromBytesMutex.Unlock() + fake.SetFromBytesStub = nil + fake.setFromBytesReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) SetFromBytesReturnsOnCall(i int, result1 error) { + fake.setFromBytesMutex.Lock() + defer fake.setFromBytesMutex.Unlock() + fake.SetFromBytesStub = nil + if fake.setFromBytesReturnsOnCall == nil { + fake.setFromBytesReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setFromBytesReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) SetFromEnvelopeBytes(arg1 []byte) error { + var arg1Copy []byte + if arg1 != nil { + arg1Copy = make([]byte, len(arg1)) + copy(arg1Copy, arg1) + } + fake.setFromEnvelopeBytesMutex.Lock() + ret, specificReturn := fake.setFromEnvelopeBytesReturnsOnCall[len(fake.setFromEnvelopeBytesArgsForCall)] + fake.setFromEnvelopeBytesArgsForCall = append(fake.setFromEnvelopeBytesArgsForCall, struct { + arg1 []byte + }{arg1Copy}) + stub := fake.SetFromEnvelopeBytesStub + fakeReturns := fake.setFromEnvelopeBytesReturns + fake.recordInvocation("SetFromEnvelopeBytes", []interface{}{arg1Copy}) + fake.setFromEnvelopeBytesMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) SetFromEnvelopeBytesCallCount() int { + fake.setFromEnvelopeBytesMutex.RLock() + defer fake.setFromEnvelopeBytesMutex.RUnlock() + return len(fake.setFromEnvelopeBytesArgsForCall) +} + +func (fake *FabricTransaction) SetFromEnvelopeBytesCalls(stub func([]byte) error) { + fake.setFromEnvelopeBytesMutex.Lock() + defer fake.setFromEnvelopeBytesMutex.Unlock() + fake.SetFromEnvelopeBytesStub = stub +} + +func (fake *FabricTransaction) SetFromEnvelopeBytesArgsForCall(i int) []byte { + fake.setFromEnvelopeBytesMutex.RLock() + defer fake.setFromEnvelopeBytesMutex.RUnlock() + argsForCall := fake.setFromEnvelopeBytesArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FabricTransaction) SetFromEnvelopeBytesReturns(result1 error) { + fake.setFromEnvelopeBytesMutex.Lock() + defer fake.setFromEnvelopeBytesMutex.Unlock() + fake.SetFromEnvelopeBytesStub = nil + fake.setFromEnvelopeBytesReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) SetFromEnvelopeBytesReturnsOnCall(i int, result1 error) { + fake.setFromEnvelopeBytesMutex.Lock() + defer fake.setFromEnvelopeBytesMutex.Unlock() + fake.SetFromEnvelopeBytesStub = nil + if fake.setFromEnvelopeBytesReturnsOnCall == nil { + fake.setFromEnvelopeBytesReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setFromEnvelopeBytesReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) SetParameterAt(arg1 int, arg2 []byte) error { + var arg2Copy []byte + if arg2 != nil { + arg2Copy = make([]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.setParameterAtMutex.Lock() + ret, specificReturn := fake.setParameterAtReturnsOnCall[len(fake.setParameterAtArgsForCall)] + fake.setParameterAtArgsForCall = append(fake.setParameterAtArgsForCall, struct { + arg1 int + arg2 []byte + }{arg1, arg2Copy}) + stub := fake.SetParameterAtStub + fakeReturns := fake.setParameterAtReturns + fake.recordInvocation("SetParameterAt", []interface{}{arg1, arg2Copy}) + fake.setParameterAtMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) SetParameterAtCallCount() int { + fake.setParameterAtMutex.RLock() + defer fake.setParameterAtMutex.RUnlock() + return len(fake.setParameterAtArgsForCall) +} + +func (fake *FabricTransaction) SetParameterAtCalls(stub func(int, []byte) error) { + fake.setParameterAtMutex.Lock() + defer fake.setParameterAtMutex.Unlock() + fake.SetParameterAtStub = stub +} + +func (fake *FabricTransaction) SetParameterAtArgsForCall(i int) (int, []byte) { + fake.setParameterAtMutex.RLock() + defer fake.setParameterAtMutex.RUnlock() + argsForCall := fake.setParameterAtArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FabricTransaction) SetParameterAtReturns(result1 error) { + fake.setParameterAtMutex.Lock() + defer fake.setParameterAtMutex.Unlock() + fake.SetParameterAtStub = nil + fake.setParameterAtReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) SetParameterAtReturnsOnCall(i int, result1 error) { + fake.setParameterAtMutex.Lock() + defer fake.setParameterAtMutex.Unlock() + fake.SetParameterAtStub = nil + if fake.setParameterAtReturnsOnCall == nil { + fake.setParameterAtReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setParameterAtReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) SetProposal(arg1 string, arg2 string, arg3 string, arg4 ...string) { + fake.setProposalMutex.Lock() + fake.setProposalArgsForCall = append(fake.setProposalArgsForCall, struct { + arg1 string + arg2 string + arg3 string + arg4 []string + }{arg1, arg2, arg3, arg4}) + stub := fake.SetProposalStub + fake.recordInvocation("SetProposal", []interface{}{arg1, arg2, arg3, arg4}) + fake.setProposalMutex.Unlock() + if stub != nil { + fake.SetProposalStub(arg1, arg2, arg3, arg4...) + } +} + +func (fake *FabricTransaction) SetProposalCallCount() int { + fake.setProposalMutex.RLock() + defer fake.setProposalMutex.RUnlock() + return len(fake.setProposalArgsForCall) +} + +func (fake *FabricTransaction) SetProposalCalls(stub func(string, string, string, ...string)) { + fake.setProposalMutex.Lock() + defer fake.setProposalMutex.Unlock() + fake.SetProposalStub = stub +} + +func (fake *FabricTransaction) SetProposalArgsForCall(i int) (string, string, string, []string) { + fake.setProposalMutex.RLock() + defer fake.setProposalMutex.RUnlock() + argsForCall := fake.setProposalArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FabricTransaction) SetRWSet() error { + fake.setRWSetMutex.Lock() + ret, specificReturn := fake.setRWSetReturnsOnCall[len(fake.setRWSetArgsForCall)] + fake.setRWSetArgsForCall = append(fake.setRWSetArgsForCall, struct { + }{}) + stub := fake.SetRWSetStub + fakeReturns := fake.setRWSetReturns + fake.recordInvocation("SetRWSet", []interface{}{}) + fake.setRWSetMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) SetRWSetCallCount() int { + fake.setRWSetMutex.RLock() + defer fake.setRWSetMutex.RUnlock() + return len(fake.setRWSetArgsForCall) +} + +func (fake *FabricTransaction) SetRWSetCalls(stub func() error) { + fake.setRWSetMutex.Lock() + defer fake.setRWSetMutex.Unlock() + fake.SetRWSetStub = stub +} + +func (fake *FabricTransaction) SetRWSetReturns(result1 error) { + fake.setRWSetMutex.Lock() + defer fake.setRWSetMutex.Unlock() + fake.SetRWSetStub = nil + fake.setRWSetReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) SetRWSetReturnsOnCall(i int, result1 error) { + fake.setRWSetMutex.Lock() + defer fake.setRWSetMutex.Unlock() + fake.SetRWSetStub = nil + if fake.setRWSetReturnsOnCall == nil { + fake.setRWSetReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setRWSetReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) SignedProposal() driver.SignedProposal { + fake.signedProposalMutex.Lock() + ret, specificReturn := fake.signedProposalReturnsOnCall[len(fake.signedProposalArgsForCall)] + fake.signedProposalArgsForCall = append(fake.signedProposalArgsForCall, struct { + }{}) + stub := fake.SignedProposalStub + fakeReturns := fake.signedProposalReturns + fake.recordInvocation("SignedProposal", []interface{}{}) + fake.signedProposalMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) SignedProposalCallCount() int { + fake.signedProposalMutex.RLock() + defer fake.signedProposalMutex.RUnlock() + return len(fake.signedProposalArgsForCall) +} + +func (fake *FabricTransaction) SignedProposalCalls(stub func() driver.SignedProposal) { + fake.signedProposalMutex.Lock() + defer fake.signedProposalMutex.Unlock() + fake.SignedProposalStub = stub +} + +func (fake *FabricTransaction) SignedProposalReturns(result1 driver.SignedProposal) { + fake.signedProposalMutex.Lock() + defer fake.signedProposalMutex.Unlock() + fake.SignedProposalStub = nil + fake.signedProposalReturns = struct { + result1 driver.SignedProposal + }{result1} +} + +func (fake *FabricTransaction) SignedProposalReturnsOnCall(i int, result1 driver.SignedProposal) { + fake.signedProposalMutex.Lock() + defer fake.signedProposalMutex.Unlock() + fake.SignedProposalStub = nil + if fake.signedProposalReturnsOnCall == nil { + fake.signedProposalReturnsOnCall = make(map[int]struct { + result1 driver.SignedProposal + }) + } + fake.signedProposalReturnsOnCall[i] = struct { + result1 driver.SignedProposal + }{result1} +} + +func (fake *FabricTransaction) StoreTransient() error { + fake.storeTransientMutex.Lock() + ret, specificReturn := fake.storeTransientReturnsOnCall[len(fake.storeTransientArgsForCall)] + fake.storeTransientArgsForCall = append(fake.storeTransientArgsForCall, struct { + }{}) + stub := fake.StoreTransientStub + fakeReturns := fake.storeTransientReturns + fake.recordInvocation("StoreTransient", []interface{}{}) + fake.storeTransientMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) StoreTransientCallCount() int { + fake.storeTransientMutex.RLock() + defer fake.storeTransientMutex.RUnlock() + return len(fake.storeTransientArgsForCall) +} + +func (fake *FabricTransaction) StoreTransientCalls(stub func() error) { + fake.storeTransientMutex.Lock() + defer fake.storeTransientMutex.Unlock() + fake.StoreTransientStub = stub +} + +func (fake *FabricTransaction) StoreTransientReturns(result1 error) { + fake.storeTransientMutex.Lock() + defer fake.storeTransientMutex.Unlock() + fake.StoreTransientStub = nil + fake.storeTransientReturns = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) StoreTransientReturnsOnCall(i int, result1 error) { + fake.storeTransientMutex.Lock() + defer fake.storeTransientMutex.Unlock() + fake.StoreTransientStub = nil + if fake.storeTransientReturnsOnCall == nil { + fake.storeTransientReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.storeTransientReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FabricTransaction) Transient() driver.TransientMap { + fake.transientMutex.Lock() + ret, specificReturn := fake.transientReturnsOnCall[len(fake.transientArgsForCall)] + fake.transientArgsForCall = append(fake.transientArgsForCall, struct { + }{}) + stub := fake.TransientStub + fakeReturns := fake.transientReturns + fake.recordInvocation("Transient", []interface{}{}) + fake.transientMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FabricTransaction) TransientCallCount() int { + fake.transientMutex.RLock() + defer fake.transientMutex.RUnlock() + return len(fake.transientArgsForCall) +} + +func (fake *FabricTransaction) TransientCalls(stub func() driver.TransientMap) { + fake.transientMutex.Lock() + defer fake.transientMutex.Unlock() + fake.TransientStub = stub +} + +func (fake *FabricTransaction) TransientReturns(result1 driver.TransientMap) { + fake.transientMutex.Lock() + defer fake.transientMutex.Unlock() + fake.TransientStub = nil + fake.transientReturns = struct { + result1 driver.TransientMap + }{result1} +} + +func (fake *FabricTransaction) TransientReturnsOnCall(i int, result1 driver.TransientMap) { + fake.transientMutex.Lock() + defer fake.transientMutex.Unlock() + fake.TransientStub = nil + if fake.transientReturnsOnCall == nil { + fake.transientReturnsOnCall = make(map[int]struct { + result1 driver.TransientMap + }) + } + fake.transientReturnsOnCall[i] = struct { + result1 driver.TransientMap + }{result1} +} + +func (fake *FabricTransaction) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.appendParameterMutex.RLock() + defer fake.appendParameterMutex.RUnlock() + fake.appendProposalResponseMutex.RLock() + defer fake.appendProposalResponseMutex.RUnlock() + fake.bytesMutex.RLock() + defer fake.bytesMutex.RUnlock() + fake.bytesNoTransientMutex.RLock() + defer fake.bytesNoTransientMutex.RUnlock() + fake.chaincodeMutex.RLock() + defer fake.chaincodeMutex.RUnlock() + fake.chaincodeVersionMutex.RLock() + defer fake.chaincodeVersionMutex.RUnlock() + fake.channelMutex.RLock() + defer fake.channelMutex.RUnlock() + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + fake.creatorMutex.RLock() + defer fake.creatorMutex.RUnlock() + fake.doneMutex.RLock() + defer fake.doneMutex.RUnlock() + fake.endorseMutex.RLock() + defer fake.endorseMutex.RUnlock() + fake.endorseProposalMutex.RLock() + defer fake.endorseProposalMutex.RUnlock() + fake.endorseProposalResponseMutex.RLock() + defer fake.endorseProposalResponseMutex.RUnlock() + fake.endorseProposalResponseWithIdentityMutex.RLock() + defer fake.endorseProposalResponseWithIdentityMutex.RUnlock() + fake.endorseProposalWithIdentityMutex.RLock() + defer fake.endorseProposalWithIdentityMutex.RUnlock() + fake.endorseWithIdentityMutex.RLock() + defer fake.endorseWithIdentityMutex.RUnlock() + fake.endorseWithSignerMutex.RLock() + defer fake.endorseWithSignerMutex.RUnlock() + fake.envelopeMutex.RLock() + defer fake.envelopeMutex.RUnlock() + fake.fromMutex.RLock() + defer fake.fromMutex.RUnlock() + fake.functionMutex.RLock() + defer fake.functionMutex.RUnlock() + fake.functionAndParametersMutex.RLock() + defer fake.functionAndParametersMutex.RUnlock() + fake.getRWSetMutex.RLock() + defer fake.getRWSetMutex.RUnlock() + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + fake.networkMutex.RLock() + defer fake.networkMutex.RUnlock() + fake.nonceMutex.RLock() + defer fake.nonceMutex.RUnlock() + fake.parametersMutex.RLock() + defer fake.parametersMutex.RUnlock() + fake.proposalMutex.RLock() + defer fake.proposalMutex.RUnlock() + fake.proposalHasBeenEndorsedByMutex.RLock() + defer fake.proposalHasBeenEndorsedByMutex.RUnlock() + fake.proposalResponseMutex.RLock() + defer fake.proposalResponseMutex.RUnlock() + fake.proposalResponsesMutex.RLock() + defer fake.proposalResponsesMutex.RUnlock() + fake.rWSMutex.RLock() + defer fake.rWSMutex.RUnlock() + fake.rawMutex.RLock() + defer fake.rawMutex.RUnlock() + fake.resetTransientMutex.RLock() + defer fake.resetTransientMutex.RUnlock() + fake.resultsMutex.RLock() + defer fake.resultsMutex.RUnlock() + fake.setFromBytesMutex.RLock() + defer fake.setFromBytesMutex.RUnlock() + fake.setFromEnvelopeBytesMutex.RLock() + defer fake.setFromEnvelopeBytesMutex.RUnlock() + fake.setParameterAtMutex.RLock() + defer fake.setParameterAtMutex.RUnlock() + fake.setProposalMutex.RLock() + defer fake.setProposalMutex.RUnlock() + fake.setRWSetMutex.RLock() + defer fake.setRWSetMutex.RUnlock() + fake.signedProposalMutex.RLock() + defer fake.signedProposalMutex.RUnlock() + fake.storeTransientMutex.RLock() + defer fake.storeTransientMutex.RUnlock() + fake.transientMutex.RLock() + defer fake.transientMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FabricTransaction) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fsc.FabricTransaction = new(FabricTransaction) diff --git a/token/services/network/fabric/endorsement/fsc/mock/storage.go b/token/services/network/fabric/endorsement/fsc/mock/storage.go new file mode 100644 index 000000000..f1a457f10 --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/mock/storage.go @@ -0,0 +1,126 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" +) + +type Storage struct { + AppendValidationRecordStub func(context.Context, string, []byte, map[string][]byte, driver.PPHash) error + appendValidationRecordMutex sync.RWMutex + appendValidationRecordArgsForCall []struct { + arg1 context.Context + arg2 string + arg3 []byte + arg4 map[string][]byte + arg5 driver.PPHash + } + appendValidationRecordReturns struct { + result1 error + } + appendValidationRecordReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Storage) AppendValidationRecord(arg1 context.Context, arg2 string, arg3 []byte, arg4 map[string][]byte, arg5 driver.PPHash) error { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.appendValidationRecordMutex.Lock() + ret, specificReturn := fake.appendValidationRecordReturnsOnCall[len(fake.appendValidationRecordArgsForCall)] + fake.appendValidationRecordArgsForCall = append(fake.appendValidationRecordArgsForCall, struct { + arg1 context.Context + arg2 string + arg3 []byte + arg4 map[string][]byte + arg5 driver.PPHash + }{arg1, arg2, arg3Copy, arg4, arg5}) + stub := fake.AppendValidationRecordStub + fakeReturns := fake.appendValidationRecordReturns + fake.recordInvocation("AppendValidationRecord", []interface{}{arg1, arg2, arg3Copy, arg4, arg5}) + fake.appendValidationRecordMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Storage) AppendValidationRecordCallCount() int { + fake.appendValidationRecordMutex.RLock() + defer fake.appendValidationRecordMutex.RUnlock() + return len(fake.appendValidationRecordArgsForCall) +} + +func (fake *Storage) AppendValidationRecordCalls(stub func(context.Context, string, []byte, map[string][]byte, driver.PPHash) error) { + fake.appendValidationRecordMutex.Lock() + defer fake.appendValidationRecordMutex.Unlock() + fake.AppendValidationRecordStub = stub +} + +func (fake *Storage) AppendValidationRecordArgsForCall(i int) (context.Context, string, []byte, map[string][]byte, driver.PPHash) { + fake.appendValidationRecordMutex.RLock() + defer fake.appendValidationRecordMutex.RUnlock() + argsForCall := fake.appendValidationRecordArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 +} + +func (fake *Storage) AppendValidationRecordReturns(result1 error) { + fake.appendValidationRecordMutex.Lock() + defer fake.appendValidationRecordMutex.Unlock() + fake.AppendValidationRecordStub = nil + fake.appendValidationRecordReturns = struct { + result1 error + }{result1} +} + +func (fake *Storage) AppendValidationRecordReturnsOnCall(i int, result1 error) { + fake.appendValidationRecordMutex.Lock() + defer fake.appendValidationRecordMutex.Unlock() + fake.AppendValidationRecordStub = nil + if fake.appendValidationRecordReturnsOnCall == nil { + fake.appendValidationRecordReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.appendValidationRecordReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Storage) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.appendValidationRecordMutex.RLock() + defer fake.appendValidationRecordMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Storage) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fsc.Storage = new(Storage) diff --git a/token/services/network/fabric/endorsement/fsc/mock/storage_provider.go b/token/services/network/fabric/endorsement/fsc/mock/storage_provider.go new file mode 100644 index 000000000..1bcf875fc --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/mock/storage_provider.go @@ -0,0 +1,117 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" +) + +type StorageProvider struct { + GetStorageStub func(token.TMSID) (fsc.Storage, error) + getStorageMutex sync.RWMutex + getStorageArgsForCall []struct { + arg1 token.TMSID + } + getStorageReturns struct { + result1 fsc.Storage + result2 error + } + getStorageReturnsOnCall map[int]struct { + result1 fsc.Storage + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *StorageProvider) GetStorage(arg1 token.TMSID) (fsc.Storage, error) { + fake.getStorageMutex.Lock() + ret, specificReturn := fake.getStorageReturnsOnCall[len(fake.getStorageArgsForCall)] + fake.getStorageArgsForCall = append(fake.getStorageArgsForCall, struct { + arg1 token.TMSID + }{arg1}) + stub := fake.GetStorageStub + fakeReturns := fake.getStorageReturns + fake.recordInvocation("GetStorage", []interface{}{arg1}) + fake.getStorageMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *StorageProvider) GetStorageCallCount() int { + fake.getStorageMutex.RLock() + defer fake.getStorageMutex.RUnlock() + return len(fake.getStorageArgsForCall) +} + +func (fake *StorageProvider) GetStorageCalls(stub func(token.TMSID) (fsc.Storage, error)) { + fake.getStorageMutex.Lock() + defer fake.getStorageMutex.Unlock() + fake.GetStorageStub = stub +} + +func (fake *StorageProvider) GetStorageArgsForCall(i int) token.TMSID { + fake.getStorageMutex.RLock() + defer fake.getStorageMutex.RUnlock() + argsForCall := fake.getStorageArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *StorageProvider) GetStorageReturns(result1 fsc.Storage, result2 error) { + fake.getStorageMutex.Lock() + defer fake.getStorageMutex.Unlock() + fake.GetStorageStub = nil + fake.getStorageReturns = struct { + result1 fsc.Storage + result2 error + }{result1, result2} +} + +func (fake *StorageProvider) GetStorageReturnsOnCall(i int, result1 fsc.Storage, result2 error) { + fake.getStorageMutex.Lock() + defer fake.getStorageMutex.Unlock() + fake.GetStorageStub = nil + if fake.getStorageReturnsOnCall == nil { + fake.getStorageReturnsOnCall = make(map[int]struct { + result1 fsc.Storage + result2 error + }) + } + fake.getStorageReturnsOnCall[i] = struct { + result1 fsc.Storage + result2 error + }{result1, result2} +} + +func (fake *StorageProvider) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.getStorageMutex.RLock() + defer fake.getStorageMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *StorageProvider) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fsc.StorageProvider = new(StorageProvider) diff --git a/token/services/network/fabric/endorsement/fsc/mock/tmsp.go b/token/services/network/fabric/endorsement/fsc/mock/tmsp.go new file mode 100644 index 000000000..9b38cf668 --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/mock/tmsp.go @@ -0,0 +1,117 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" +) + +type TokenManagementSystemProvider struct { + GetManagementServiceStub func(...token.ServiceOption) (*token.ManagementService, error) + getManagementServiceMutex sync.RWMutex + getManagementServiceArgsForCall []struct { + arg1 []token.ServiceOption + } + getManagementServiceReturns struct { + result1 *token.ManagementService + result2 error + } + getManagementServiceReturnsOnCall map[int]struct { + result1 *token.ManagementService + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *TokenManagementSystemProvider) GetManagementService(arg1 ...token.ServiceOption) (*token.ManagementService, error) { + fake.getManagementServiceMutex.Lock() + ret, specificReturn := fake.getManagementServiceReturnsOnCall[len(fake.getManagementServiceArgsForCall)] + fake.getManagementServiceArgsForCall = append(fake.getManagementServiceArgsForCall, struct { + arg1 []token.ServiceOption + }{arg1}) + stub := fake.GetManagementServiceStub + fakeReturns := fake.getManagementServiceReturns + fake.recordInvocation("GetManagementService", []interface{}{arg1}) + fake.getManagementServiceMutex.Unlock() + if stub != nil { + return stub(arg1...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *TokenManagementSystemProvider) GetManagementServiceCallCount() int { + fake.getManagementServiceMutex.RLock() + defer fake.getManagementServiceMutex.RUnlock() + return len(fake.getManagementServiceArgsForCall) +} + +func (fake *TokenManagementSystemProvider) GetManagementServiceCalls(stub func(...token.ServiceOption) (*token.ManagementService, error)) { + fake.getManagementServiceMutex.Lock() + defer fake.getManagementServiceMutex.Unlock() + fake.GetManagementServiceStub = stub +} + +func (fake *TokenManagementSystemProvider) GetManagementServiceArgsForCall(i int) []token.ServiceOption { + fake.getManagementServiceMutex.RLock() + defer fake.getManagementServiceMutex.RUnlock() + argsForCall := fake.getManagementServiceArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *TokenManagementSystemProvider) GetManagementServiceReturns(result1 *token.ManagementService, result2 error) { + fake.getManagementServiceMutex.Lock() + defer fake.getManagementServiceMutex.Unlock() + fake.GetManagementServiceStub = nil + fake.getManagementServiceReturns = struct { + result1 *token.ManagementService + result2 error + }{result1, result2} +} + +func (fake *TokenManagementSystemProvider) GetManagementServiceReturnsOnCall(i int, result1 *token.ManagementService, result2 error) { + fake.getManagementServiceMutex.Lock() + defer fake.getManagementServiceMutex.Unlock() + fake.GetManagementServiceStub = nil + if fake.getManagementServiceReturnsOnCall == nil { + fake.getManagementServiceReturnsOnCall = make(map[int]struct { + result1 *token.ManagementService + result2 error + }) + } + fake.getManagementServiceReturnsOnCall[i] = struct { + result1 *token.ManagementService + result2 error + }{result1, result2} +} + +func (fake *TokenManagementSystemProvider) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.getManagementServiceMutex.RLock() + defer fake.getManagementServiceMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *TokenManagementSystemProvider) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fsc.TokenManagementSystemProvider = new(TokenManagementSystemProvider) diff --git a/token/services/network/fabric/endorsement/fsc/mock/translator.go b/token/services/network/fabric/endorsement/fsc/mock/translator.go new file mode 100644 index 000000000..8627ed34d --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/mock/translator.go @@ -0,0 +1,265 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" +) + +type Translator struct { + AddPublicParamsDependencyStub func() error + addPublicParamsDependencyMutex sync.RWMutex + addPublicParamsDependencyArgsForCall []struct { + } + addPublicParamsDependencyReturns struct { + result1 error + } + addPublicParamsDependencyReturnsOnCall map[int]struct { + result1 error + } + CommitTokenRequestStub func([]byte, bool) ([]byte, error) + commitTokenRequestMutex sync.RWMutex + commitTokenRequestArgsForCall []struct { + arg1 []byte + arg2 bool + } + commitTokenRequestReturns struct { + result1 []byte + result2 error + } + commitTokenRequestReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + WriteStub func(context.Context, any) error + writeMutex sync.RWMutex + writeArgsForCall []struct { + arg1 context.Context + arg2 any + } + writeReturns struct { + result1 error + } + writeReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Translator) AddPublicParamsDependency() error { + fake.addPublicParamsDependencyMutex.Lock() + ret, specificReturn := fake.addPublicParamsDependencyReturnsOnCall[len(fake.addPublicParamsDependencyArgsForCall)] + fake.addPublicParamsDependencyArgsForCall = append(fake.addPublicParamsDependencyArgsForCall, struct { + }{}) + stub := fake.AddPublicParamsDependencyStub + fakeReturns := fake.addPublicParamsDependencyReturns + fake.recordInvocation("AddPublicParamsDependency", []interface{}{}) + fake.addPublicParamsDependencyMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Translator) AddPublicParamsDependencyCallCount() int { + fake.addPublicParamsDependencyMutex.RLock() + defer fake.addPublicParamsDependencyMutex.RUnlock() + return len(fake.addPublicParamsDependencyArgsForCall) +} + +func (fake *Translator) AddPublicParamsDependencyCalls(stub func() error) { + fake.addPublicParamsDependencyMutex.Lock() + defer fake.addPublicParamsDependencyMutex.Unlock() + fake.AddPublicParamsDependencyStub = stub +} + +func (fake *Translator) AddPublicParamsDependencyReturns(result1 error) { + fake.addPublicParamsDependencyMutex.Lock() + defer fake.addPublicParamsDependencyMutex.Unlock() + fake.AddPublicParamsDependencyStub = nil + fake.addPublicParamsDependencyReturns = struct { + result1 error + }{result1} +} + +func (fake *Translator) AddPublicParamsDependencyReturnsOnCall(i int, result1 error) { + fake.addPublicParamsDependencyMutex.Lock() + defer fake.addPublicParamsDependencyMutex.Unlock() + fake.AddPublicParamsDependencyStub = nil + if fake.addPublicParamsDependencyReturnsOnCall == nil { + fake.addPublicParamsDependencyReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.addPublicParamsDependencyReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Translator) CommitTokenRequest(arg1 []byte, arg2 bool) ([]byte, error) { + var arg1Copy []byte + if arg1 != nil { + arg1Copy = make([]byte, len(arg1)) + copy(arg1Copy, arg1) + } + fake.commitTokenRequestMutex.Lock() + ret, specificReturn := fake.commitTokenRequestReturnsOnCall[len(fake.commitTokenRequestArgsForCall)] + fake.commitTokenRequestArgsForCall = append(fake.commitTokenRequestArgsForCall, struct { + arg1 []byte + arg2 bool + }{arg1Copy, arg2}) + stub := fake.CommitTokenRequestStub + fakeReturns := fake.commitTokenRequestReturns + fake.recordInvocation("CommitTokenRequest", []interface{}{arg1Copy, arg2}) + fake.commitTokenRequestMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Translator) CommitTokenRequestCallCount() int { + fake.commitTokenRequestMutex.RLock() + defer fake.commitTokenRequestMutex.RUnlock() + return len(fake.commitTokenRequestArgsForCall) +} + +func (fake *Translator) CommitTokenRequestCalls(stub func([]byte, bool) ([]byte, error)) { + fake.commitTokenRequestMutex.Lock() + defer fake.commitTokenRequestMutex.Unlock() + fake.CommitTokenRequestStub = stub +} + +func (fake *Translator) CommitTokenRequestArgsForCall(i int) ([]byte, bool) { + fake.commitTokenRequestMutex.RLock() + defer fake.commitTokenRequestMutex.RUnlock() + argsForCall := fake.commitTokenRequestArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Translator) CommitTokenRequestReturns(result1 []byte, result2 error) { + fake.commitTokenRequestMutex.Lock() + defer fake.commitTokenRequestMutex.Unlock() + fake.CommitTokenRequestStub = nil + fake.commitTokenRequestReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *Translator) CommitTokenRequestReturnsOnCall(i int, result1 []byte, result2 error) { + fake.commitTokenRequestMutex.Lock() + defer fake.commitTokenRequestMutex.Unlock() + fake.CommitTokenRequestStub = nil + if fake.commitTokenRequestReturnsOnCall == nil { + fake.commitTokenRequestReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.commitTokenRequestReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *Translator) Write(arg1 context.Context, arg2 any) error { + fake.writeMutex.Lock() + ret, specificReturn := fake.writeReturnsOnCall[len(fake.writeArgsForCall)] + fake.writeArgsForCall = append(fake.writeArgsForCall, struct { + arg1 context.Context + arg2 any + }{arg1, arg2}) + stub := fake.WriteStub + fakeReturns := fake.writeReturns + fake.recordInvocation("Write", []interface{}{arg1, arg2}) + fake.writeMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Translator) WriteCallCount() int { + fake.writeMutex.RLock() + defer fake.writeMutex.RUnlock() + return len(fake.writeArgsForCall) +} + +func (fake *Translator) WriteCalls(stub func(context.Context, any) error) { + fake.writeMutex.Lock() + defer fake.writeMutex.Unlock() + fake.WriteStub = stub +} + +func (fake *Translator) WriteArgsForCall(i int) (context.Context, any) { + fake.writeMutex.RLock() + defer fake.writeMutex.RUnlock() + argsForCall := fake.writeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Translator) WriteReturns(result1 error) { + fake.writeMutex.Lock() + defer fake.writeMutex.Unlock() + fake.WriteStub = nil + fake.writeReturns = struct { + result1 error + }{result1} +} + +func (fake *Translator) WriteReturnsOnCall(i int, result1 error) { + fake.writeMutex.Lock() + defer fake.writeMutex.Unlock() + fake.WriteStub = nil + if fake.writeReturnsOnCall == nil { + fake.writeReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.writeReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Translator) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.addPublicParamsDependencyMutex.RLock() + defer fake.addPublicParamsDependencyMutex.RUnlock() + fake.commitTokenRequestMutex.RLock() + defer fake.commitTokenRequestMutex.RUnlock() + fake.writeMutex.RLock() + defer fake.writeMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Translator) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fsc.Translator = new(Translator) diff --git a/token/services/network/fabric/endorsement/fsc/responder.go b/token/services/network/fabric/endorsement/fsc/responder.go new file mode 100644 index 000000000..6288bfd2f --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/responder.go @@ -0,0 +1,264 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package fsc + +import ( + "context" + + "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/services/endorser" + "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" + token2 "github.com/hyperledger-labs/fabric-token-sdk/token" + "github.com/hyperledger-labs/fabric-token-sdk/token/core/common" + tdriver "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/common/rws/translator" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +const ( + TransientTMSIDKey = "tmsID" + TransientTokenRequestKey = "token_request" + + ChaincodeVersion = "1.0" + InvokeFunction = "invoke" +) + +type Request struct { + Tx *endorser.Transaction + Rws *fabric.RWSet + TMSID token2.TMSID + Anchor string + RequestRaw []byte + Actions []any + Meta map[string][]byte + Tms *token2.ManagementService + PublicParamsHash tdriver.PPHash +} + +type RequestApprovalResponderView struct { + endorserService EndorserService + keyTranslator translator.KeyTranslator + getTranslator TranslatorProviderFunc + tokenManagementSystemProvider TokenManagementSystemProvider + storageProvider StorageProvider +} + +func NewRequestApprovalResponderView( + keyTranslator translator.KeyTranslator, + getTranslator TranslatorProviderFunc, + endorserService EndorserService, + tokenManagementSystemProvider TokenManagementSystemProvider, + storageProvider StorageProvider, +) *RequestApprovalResponderView { + return &RequestApprovalResponderView{ + keyTranslator: keyTranslator, + getTranslator: getTranslator, + endorserService: endorserService, + tokenManagementSystemProvider: tokenManagementSystemProvider, + storageProvider: storageProvider, + } +} + +func (r *RequestApprovalResponderView) Call(context view.Context) (any, error) { + // receive + request, err := r.receive(context) + if err != nil { + return nil, errors.Join(ErrReceivedProposal, err) + } + defer request.Rws.Done() + + // validate + err = r.validate(context, request, func(id token.ID) ([]byte, error) { + key, err := r.keyTranslator.CreateOutputKey(id.TxId, id.Index) + if err != nil { + return nil, errors.WithMessagef(err, "failed to create token key for id [%s]", id) + } + return request.Rws.GetDirectState(request.TMSID.Namespace, key) + }) + if err != nil { + return nil, errors.Join(ErrValidateProposal, err) + } + + // endorse + res, err := r.endorse(context, request) + if err != nil { + return nil, errors.Join(ErrEndorseProposal, err) + } + return res, nil +} + +func (r *RequestApprovalResponderView) receive(ctx view.Context) (*Request, error) { + logger.DebugfContext(ctx.Context(), "Waiting for transaction on context [%s]", ctx.ID()) + tx, err := r.endorserService.ReceiveTx(ctx) + if err != nil { + return nil, errors.WithMessagef(err, "failed to received transaction for approval") + } + logger.DebugfContext(ctx.Context(), "Received transaction [%s] for endorsement on context [%s]", tx.ID(), ctx.ID()) + defer logger.DebugfContext(ctx.Context(), "Return endorsement result for TX [%s]", tx.ID()) + + // validate transient + + // check the number of transient keys + var tmsID token2.TMSID + if len(tx.Transaction.Transient()) != 2 { + return nil, errors.Wrapf(ErrInvalidTransient, "invalid number of transient field, expected 2, got %d", len(tx.Transaction.Transient())) + } + + // TMS ID + if err := tx.GetTransientState(TransientTMSIDKey, &tmsID); err != nil { + return nil, errors.Wrapf(errors.Join(err, ErrInvalidTransient), "empty tms id") + } + if len(tmsID.Network) == 0 || len(tmsID.Channel) == 0 || len(tmsID.Namespace) == 0 { + return nil, errors.Wrapf(errors.Join(err, ErrInvalidTransient), "invalid tms id [%s]", tmsID) + } + tms, err := r.tokenManagementSystemProvider.GetManagementService(token2.WithTMSID(tmsID)) + if err != nil { + return nil, errors.Wrapf(errors.Join(err, ErrInvalidTransient), "cannot find TMS for [%s]", tmsID) + } + if !tms.ID().Equal(tmsID) { + return nil, errors.Wrapf(errors.Join(err, ErrInvalidTransient), "tms ids do not match") + } + logger.DebugfContext(ctx.Context(), "evaluate token request on TMS [%s]", tmsID) + + // token request + requestRaw := tx.GetTransient(TransientTokenRequestKey) + if len(requestRaw) == 0 { + return nil, errors.Wrapf(ErrInvalidTransient, "empty token request") + } + + // request anchor + requestAnchor := tx.ID() + + // rws + rws, err := tx.RWSet() + if err != nil { + return nil, errors.Wrapf(errors.Join(ErrInvalidProposal, err), "failed to get rws for tx [%s]", tx.ID()) + } + defer func() { + // if an error occurred, then call Done on the rwset + if rws != nil { + rws.Done() + } + }() + + // the rws must be empty + if len(rws.Namespaces()) != 0 { + return nil, errors.Wrapf(ErrInvalidProposal, "non empty namespaces") + } + + // TODO: check that tx contains a valid endorser proposal + if name, version := tx.Chaincode(); name != tmsID.Namespace || version != ChaincodeVersion { + return nil, errors.Wrapf(ErrInvalidProposal, "invalid chaincode") + } + fn, parms := tx.FunctionAndParameters() + if len(parms) != 0 { + return nil, errors.Wrapf(ErrInvalidProposal, "invalid parameters") + } + if fn != InvokeFunction { + return nil, errors.Wrapf(ErrInvalidProposal, "invalid function [%s]", fn) + } + + // copy rws to make sure Done is not invoked on it, see defer above + returnRws := rws + rws = nil + + return &Request{ + Tx: tx, + Rws: returnRws, + TMSID: tmsID, + RequestRaw: requestRaw, + Anchor: requestAnchor, + Tms: tms, + PublicParamsHash: tms.PublicParametersManager().PublicParamsHash(), + }, nil +} + +func (r *RequestApprovalResponderView) translate(ctx context.Context, request *Request) error { + // prepare the rws as usual + txID := request.Anchor + w, err := r.getTranslator(txID, request.TMSID.Namespace, request.Rws) + if err != nil { + return errors.Wrapf(err, "failed to get translator for tx [%s]", request.Anchor) + } + for _, action := range request.Actions { + if err := w.Write(ctx, action); err != nil { + return errors.Wrapf(err, "failed to write token action for tx [%s]", txID) + } + } + err = w.AddPublicParamsDependency() + if err != nil { + return errors.Wrapf(err, "failed to add public params dependency") + } + _, err = w.CommitTokenRequest(request.Meta[common.TokenRequestToSign], true) + if err != nil { + return errors.Wrapf(err, "failed to write token request") + } + return nil +} + +func (r *RequestApprovalResponderView) validate(context view.Context, request *Request, getState tdriver.GetStateFnc) error { + logger.DebugfContext(context.Context(), "Validate TX [%s]", request.Anchor) + + defer logger.DebugfContext(context.Context(), "Finished validation of TX [%s]", request.Anchor) + logger.DebugfContext(context.Context(), "Get validator for TX [%s]", request.Anchor) + validator, err := request.Tms.Validator() + if err != nil { + return errors.WithMessagef(err, "failed to get validator [%s]", request.TMSID) + } + logger.DebugfContext(context.Context(), "Unmarshal and verify with metadata for TX [%s]", request.Anchor) + actions, meta, err := validator.UnmarshallAndVerifyWithMetadata( + context.Context(), + token2.NewLedgerFromGetter(getState), + token2.RequestAnchor(request.Anchor), + request.RequestRaw, + ) + if err != nil { + return errors.WithMessagef(err, "failed to verify token request for [%s]", request.Anchor) + } + db, err := r.storageProvider.GetStorage(request.TMSID) + if err != nil { + return errors.WithMessagef(err, "failed to retrieve db [%s]", request.TMSID) + } + logger.DebugfContext(context.Context(), "Append validation record for TX [%s]", request.Anchor) + if err := db.AppendValidationRecord( + context.Context(), + request.Anchor, + request.RequestRaw, + meta, + request.PublicParamsHash, + ); err != nil { + return errors.WithMessagef(err, "failed to append metadata for [%s]", request.Anchor) + } + request.Actions = actions + request.Meta = meta + return nil +} + +func (r *RequestApprovalResponderView) endorse(ctx view.Context, request *Request) (any, error) { + // endorse + logger.DebugfContext(ctx.Context(), "Endorse TX [%s]", request.Anchor) + endorserID, err := r.endorserService.EndorserID(request.TMSID) + if err != nil { + return nil, err + } + + // write actions into the transaction + logger.DebugfContext(ctx.Context(), "Translate TX [%s]", request.Anchor) + err = r.translate(ctx.Context(), request) + if err != nil { + return nil, err + } + + logger.DebugfContext(ctx.Context(), "Endorse proposal for TX [%s]", request.Anchor) + endorsementResult, err := r.endorserService.Endorse(ctx, request.Tx, endorserID) + if err != nil { + logger.Errorf("failed to respond to endorsement [%s]", err) + } + logger.DebugfContext(ctx.Context(), "Finished endorsement on TX [%s]", request.Anchor) + return endorsementResult, err +} diff --git a/token/services/network/fabric/endorsement/fsc/responder_test.go b/token/services/network/fabric/endorsement/fsc/responder_test.go new file mode 100644 index 000000000..6271966b4 --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/responder_test.go @@ -0,0 +1,290 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package fsc_test + +import ( + "encoding/json" + "testing" + + "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" + "github.com/hyperledger-labs/fabric-smart-client/platform/common/driver" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/services/endorser" + "github.com/hyperledger-labs/fabric-token-sdk/token" + mock2 "github.com/hyperledger-labs/fabric-token-sdk/token/driver/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/tokenapi" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +type MockNewRequestApprovalResponderView struct { + view *fsc.RequestApprovalResponderView + ctx *mock.Context + fabricTx *mock.FabricTransaction + tmsIDRaw []byte + validator *mock2.Validator + rws *mock.FabricRWSet + es *mock.EndorserService +} + +func mockNewRequestApprovalResponderView(t *testing.T, overrideTMSID *token.TMSID) *MockNewRequestApprovalResponderView { + t.Helper() + + ctx := &mock.Context{} + ctx.ContextReturns(t.Context()) + es := &mock.EndorserService{} + fabricTx := &mock.FabricTransaction{} + fabricTx.IDReturns("a_tx_id") + tmsID := token.TMSID{ + Network: "a_network", + Channel: "a_channel", + Namespace: "a_namespace", + } + if overrideTMSID != nil { + tmsID = *overrideTMSID + } + tmsIDRaw, err := json.Marshal(tmsID) + require.NoError(t, err) + fabricTx.TransientReturns(map[string][]byte{ + fsc.TransientTMSIDKey: tmsIDRaw, + fsc.TransientTokenRequestKey: []byte("a_token_request"), + }) + rws := &mock.FabricRWSet{} + fabricTx.GetRWSetReturns(rws, nil) + fabricTx.ChaincodeReturns("a_namespace") + fabricTx.ChaincodeVersionReturns(fsc.ChaincodeVersion) + fabricTx.FunctionReturns(fsc.InvokeFunction) + + es.ReceiveTxReturns(&endorser.Transaction{ + Provider: ctx, + Transaction: fabric.NewTransaction(nil, fabricTx), + }, nil) + tmsp := &mock.TokenManagementSystemProvider{} + tms, validator := tokenapi.NewMockedManagementServiceWithValidation(t, tmsID) + validator.VerifyTokenRequestFromRawReturns(nil, nil, nil) + tmsp.GetManagementServiceReturns(tms, nil) + + storage := &mock.Storage{} + storageProvider := &mock.StorageProvider{} + storageProvider.GetStorageReturns(storage, nil) + storage.AppendValidationRecordReturns(nil) + + view := fsc.NewRequestApprovalResponderView( + nil, + func(txID string, namespace string, rws *fabric.RWSet) (fsc.Translator, error) { + return &mock.Translator{}, nil + }, + es, + tmsp, + storageProvider, + ) + return &MockNewRequestApprovalResponderView{ + view: view, + ctx: ctx, + fabricTx: fabricTx, + tmsIDRaw: tmsIDRaw, + validator: validator, + rws: rws, + es: es, + } +} + +func TestRequestApprovalResponderView(t *testing.T) { + type testCase struct { + name string + setup func() *MockNewRequestApprovalResponderView + verify func(m *MockNewRequestApprovalResponderView, res any) + expectError bool + expectErrorType error + expectErrContain string + } + + testCases := []testCase{ + { + name: "failed to receive proposal", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, nil) + m.es.ReceiveTxReturns(nil, errors.New("pineapple")) + return m + }, + expectError: true, + expectErrorType: fsc.ErrReceivedProposal, + expectErrContain: "pineapple", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 0, m.rws.DoneCallCount()) + }, + }, + { + name: "invalid number of transient field", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, nil) + m.fabricTx.TransientReturns(map[string][]byte{ + "transient": []byte("transient"), + }) + return m + }, + expectError: true, + expectErrorType: fsc.ErrReceivedProposal, + expectErrContain: "invalid number of transient field, expected 2, got 1", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 0, m.rws.DoneCallCount()) + }, + }, + { + name: "missing TransientTMSIDKey", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, nil) + m.fabricTx.TransientReturns(map[string][]byte{ + "transient": []byte("transient"), + "transient2": []byte("transient2"), + }) + return m + }, + expectError: true, + expectErrorType: fsc.ErrReceivedProposal, + expectErrContain: "transient map key [tmsID] does not exists", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 0, m.rws.DoneCallCount()) + }, + }, + { + name: "tmsid network empty", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, &token.TMSID{}) + return m + }, + expectError: true, + expectErrorType: fsc.ErrReceivedProposal, + expectErrContain: "invalid tms id [,,]", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 0, m.rws.DoneCallCount()) + }, + }, + { + name: "tmsid channel empty", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, &token.TMSID{ + Network: "a_network", + }) + return m + }, + expectError: true, + expectErrorType: fsc.ErrReceivedProposal, + expectErrContain: "invalid tms id [a_network,,]", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 0, m.rws.DoneCallCount()) + }, + }, + { + name: "tmsid namespace empty", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, &token.TMSID{ + Network: "a_network", + Channel: "a_channel", + }) + return m + }, + expectError: true, + expectErrorType: fsc.ErrReceivedProposal, + expectErrContain: "invalid tms id [a_network,a_channel,]", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 0, m.rws.DoneCallCount()) + }, + }, + { + name: "empty token request", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, nil) + m.fabricTx.TransientReturns(map[string][]byte{ + fsc.TransientTMSIDKey: m.tmsIDRaw, + "transient2": []byte("transient2"), + }) + return m + }, + expectError: true, + expectErrorType: fsc.ErrReceivedProposal, + expectErrContain: "empty token request", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 0, m.rws.DoneCallCount()) + }, + }, + { + name: "a namespace is already there", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, nil) + m.rws.NamespacesReturns([]driver.Namespace{ + "a_namespace", + }) + return m + }, + expectError: true, + expectErrorType: fsc.ErrInvalidProposal, + expectErrContain: "non empty namespaces", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 1, m.rws.DoneCallCount()) + }, + }, + { + name: "invalid function name", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, nil) + m.fabricTx.FunctionReturns("strawberry") + return m + }, + expectError: true, + expectErrorType: fsc.ErrInvalidProposal, + expectErrContain: "invalid function [strawberry]", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 1, m.rws.DoneCallCount()) + }, + }, + { + name: "validator returns an error", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, nil) + m.validator.VerifyTokenRequestFromRawReturns(nil, nil, errors.New("pineapple")) + return m + }, + expectError: true, + expectErrorType: fsc.ErrValidateProposal, + expectErrContain: "pineapple", + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 1, m.rws.DoneCallCount()) + }, + }, + { + name: "success", + setup: func() *MockNewRequestApprovalResponderView { + m := mockNewRequestApprovalResponderView(t, nil) + return m + }, + expectError: false, + verify: func(m *MockNewRequestApprovalResponderView, res any) { + assert.Equal(t, 1, m.rws.DoneCallCount()) + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + m := tc.setup() + res, err := m.view.Call(m.ctx) + if tc.expectError { + require.Error(t, err) + assert.ErrorIs(t, err, tc.expectErrorType) + assert.Contains(t, err.Error(), tc.expectErrContain) + } else { + require.NoError(t, err) + } + if tc.verify != nil { + tc.verify(m, res) + } + }) + } +} diff --git a/token/services/network/fabric/endorsement/fsc/rws.go b/token/services/network/fabric/endorsement/fsc/rws.go new file mode 100644 index 000000000..b26b6723b --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/rws.go @@ -0,0 +1,27 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package fsc + +import ( + fdriver "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" +) + +type RWSWrapper struct { + Stub *fdriver.RWSet +} + +func (rwset *RWSWrapper) SetState(namespace string, key string, value []byte) error { + return rwset.Stub.SetState(namespace, key, value) +} + +func (rwset *RWSWrapper) GetState(namespace string, key string) ([]byte, error) { + return rwset.Stub.GetState(namespace, key) +} + +func (rwset *RWSWrapper) DeleteState(namespace string, key string) error { + return rwset.Stub.DeleteState(namespace, key) +} diff --git a/token/services/network/fabric/endorsement/fsc.go b/token/services/network/fabric/endorsement/fsc/service.go similarity index 68% rename from token/services/network/fabric/endorsement/fsc.go rename to token/services/network/fabric/endorsement/fsc/service.go index c5bfa4e38..4eb76d9d4 100644 --- a/token/services/network/fabric/endorsement/fsc.go +++ b/token/services/network/fabric/endorsement/fsc/service.go @@ -4,20 +4,24 @@ Copyright IBM Corp. All Rights Reserved. SPDX-License-Identifier: Apache-2.0 */ -package endorsement +package fsc import ( "math/rand" "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" - "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" "github.com/hyperledger-labs/fabric-token-sdk/token" tdriver "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/common/rws/translator" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/driver" ) +var ( + logger = logging.MustGetLogger() +) + const ( AmIAnEndorserKey = "services.network.fabric.fsc_endorsement.endorser" EndorsersKey = "services.network.fabric.fsc_endorsement.endorsers" @@ -27,15 +31,16 @@ const ( AllPolicy = "all" ) -type FSCService struct { - TmsID token.TMSID - Endorsers []view.Identity - ViewManager ViewManager - PolicyType string +type EndorsementService struct { + TmsID token.TMSID + Endorsers []view.Identity + ViewManager ViewManager + PolicyType string + EndorserService EndorserService } -func NewFSCService( - fnsp *fabric.NetworkServiceProvider, +func NewEndorsementService( + namespaceProcessor NamespaceTxProcessor, tmsID token.TMSID, configuration tdriver.Configuration, viewRegistry ViewRegistry, @@ -43,24 +48,23 @@ func NewFSCService( identityProvider IdentityProvider, keyTranslator translator.KeyTranslator, getTranslator TranslatorProviderFunc, -) (*FSCService, error) { - nw, err := fnsp.FabricNetworkService(tmsID.Network) - if err != nil { - return nil, errors.WithMessagef(err, "failed getting fabric network service for [%s]", tmsID.Network) - } - ch, err := nw.Channel(tmsID.Channel) - if err != nil { - return nil, errors.Wrapf(err, "failed getting channel [%s]", tmsID.Channel) - } - committer := ch.Committer() + endorserService EndorserService, + tokenManagementSystemProvider TokenManagementSystemProvider, + storageProvider StorageProvider, +) (*EndorsementService, error) { if configuration.GetBool(AmIAnEndorserKey) { logger.Debug("this node is an endorser, prepare it...") - // if I'm an endorser, I need to process all token transactions - if err := committer.ProcessNamespace(tmsID.Namespace); err != nil { - return nil, errors.WithMessagef(err, "failed to add namespace to committer [%s]", tmsID.Namespace) + if err := namespaceProcessor.EnableTxProcessing(tmsID); err != nil { + return nil, errors.WithMessagef(err, "failed to add namespace to committer [%s]", tmsID) } if err := viewRegistry.RegisterResponder( - NewRequestApprovalResponderView(keyTranslator, getTranslator), + NewRequestApprovalResponderView( + keyTranslator, + getTranslator, + endorserService, + tokenManagementSystemProvider, + storageProvider, + ), &RequestApprovalView{}, ); err != nil { return nil, errors.WithMessagef(err, "failed to register approval view for [%s]", tmsID) @@ -91,15 +95,16 @@ func NewFSCService( } } - return &FSCService{ - Endorsers: endorsers, - TmsID: tmsID, - ViewManager: viewManager, - PolicyType: policyType, + return &EndorsementService{ + Endorsers: endorsers, + TmsID: tmsID, + ViewManager: viewManager, + PolicyType: policyType, + EndorserService: endorserService, }, nil } -func (e *FSCService) Endorse(context view.Context, requestRaw []byte, signer view.Identity, txID driver.TxID) (driver.Envelope, error) { +func (e *EndorsementService) Endorse(context view.Context, requestRaw []byte, signer view.Identity, txID driver.TxID) (driver.Envelope, error) { var endorsers []view.Identity switch e.PolicyType { case OneOutNPolicy: @@ -111,12 +116,14 @@ func (e *FSCService) Endorse(context view.Context, requestRaw []byte, signer vie } logger.DebugfContext(context.Context(), "request approval via fts endrosers with policy [%s]: [%d]...", e.PolicyType, len(endorsers)) - envBoxed, err := e.ViewManager.InitiateView(&RequestApprovalView{ - TMSID: e.TmsID, - RequestRaw: requestRaw, - TxID: txID, - Endorsers: endorsers, - }, context.Context()) + envBoxed, err := e.ViewManager.InitiateView(NewRequestApprovalView( + e.TmsID, + txID, + requestRaw, + nil, + endorsers, + e.EndorserService, + ), context.Context()) if err != nil { return nil, errors.WithMessagef(err, "failed to request approval") } diff --git a/token/services/network/fabric/endorsement/fsc/storage.go b/token/services/network/fabric/endorsement/fsc/storage.go new file mode 100644 index 000000000..61bae2cbd --- /dev/null +++ b/token/services/network/fabric/endorsement/fsc/storage.go @@ -0,0 +1,29 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package fsc + +import ( + "context" + + "github.com/hyperledger-labs/fabric-token-sdk/token" + tdriver "github.com/hyperledger-labs/fabric-token-sdk/token/driver" +) + +// Storage defines the interface for storing token transaction records +// +//go:generate counterfeiter -o mock/storage.go -fake-name Storage . Storage +type Storage interface { + AppendValidationRecord(ctx context.Context, txID string, tokenRequest []byte, meta map[string][]byte, ppHash tdriver.PPHash) error +} + +// StorageProvider defines the interface for obtaining token transaction storage instances +// +//go:generate counterfeiter -o mock/storage_provider.go -fake-name StorageProvider . StorageProvider +type StorageProvider interface { + // GetStorage returns the Storage instance for the given TMS ID + GetStorage(id token.TMSID) (Storage, error) +} diff --git a/token/services/network/fabric/endorsement/provider.go b/token/services/network/fabric/endorsement/provider.go index d61df5134..88ef676d7 100644 --- a/token/services/network/fabric/endorsement/provider.go +++ b/token/services/network/fabric/endorsement/provider.go @@ -7,17 +7,21 @@ SPDX-License-Identifier: Apache-2.0 package endorsement import ( - "context" + "time" "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" "github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/lazy" "github.com/hyperledger-labs/fabric-smart-client/platform/fabric" + "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/services/endorser" + "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/comm/session" "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" token2 "github.com/hyperledger-labs/fabric-token-sdk/token" "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/common" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/common/rws/translator" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttxdb" ) const ( @@ -28,37 +32,30 @@ var ( logger = logging.MustGetLogger() ) -type IdentityProvider interface { - Identity(string) view.Identity -} - -type ViewManager interface { - InitiateView(view view.View, ctx context.Context) (interface{}, error) -} - -type ViewRegistry interface { - RegisterResponder(responder view.View, initiatedBy interface{}) error -} - type ServiceProvider struct { lazy.Provider[token2.TMSID, Service] } func NewServiceProvider( fnsp *fabric.NetworkServiceProvider, + tmsp *token2.ManagementServiceProvider, configService common.Configuration, - viewManager ViewManager, - viewRegistry ViewRegistry, - identityProvider IdentityProvider, + viewManager fsc.ViewManager, + viewRegistry fsc.ViewRegistry, + identityProvider fsc.IdentityProvider, keyTranslator translator.KeyTranslator, + storeServiceManager ttxdb.StoreServiceManager, ) *ServiceProvider { l := &loader{ - fnsp: fnsp, - configService: configService, - viewManager: viewManager, - viewRegistry: viewRegistry, - identityProvider: identityProvider, - keyTranslator: keyTranslator, + fnsp: fnsp, + tmsp: tmsp, + configService: configService, + viewManager: viewManager, + viewRegistry: viewRegistry, + identityProvider: identityProvider, + keyTranslator: keyTranslator, + storeServiceManager: storeServiceManager, + fabricProvider: fnsp, } return &ServiceProvider{Provider: lazy.NewProviderWithKeyMapper(key, l.load)} } @@ -68,12 +65,15 @@ type Service interface { } type loader struct { - fnsp *fabric.NetworkServiceProvider - configService common.Configuration - viewManager ViewManager - viewRegistry ViewRegistry - identityProvider IdentityProvider - keyTranslator translator.KeyTranslator + tmsp *token2.ManagementServiceProvider + fnsp *fabric.NetworkServiceProvider + configService common.Configuration + viewManager fsc.ViewManager + viewRegistry fsc.ViewRegistry + identityProvider fsc.IdentityProvider + keyTranslator translator.KeyTranslator + storeServiceManager ttxdb.StoreServiceManager + fabricProvider *fabric.NetworkServiceProvider } func (l *loader) load(tmsID token2.TMSID) (Service, error) { @@ -88,24 +88,141 @@ func (l *loader) load(tmsID token2.TMSID) (Service, error) { } logger.Debugf("FSC endorsement enabled...") - return NewFSCService( - l.fnsp, + return fsc.NewEndorsementService( + NewNamespaceTxProcessor(l.fnsp), tmsID, configuration, l.viewRegistry, l.viewManager, l.identityProvider, l.keyTranslator, - func(txID string, namespace string, rws *fabric.RWSet) (Translator, error) { + func(txID string, namespace string, rws *fabric.RWSet) (fsc.Translator, error) { return translator.New( txID, - translator.NewRWSetWrapper(&RWSWrapper{Stub: rws}, namespace, txID), + translator.NewRWSetWrapper(&fsc.RWSWrapper{Stub: rws}, namespace, txID), l.keyTranslator, ), nil }, + NewEndorserService(l.tmsp, l.fabricProvider), + l.tmsp, + NewStorageProvider(l.storeServiceManager), ) } func key(tmsID token2.TMSID) string { return tmsID.Network + tmsID.Channel + tmsID.Namespace } + +// NamespaceTxProcessor models a namespace transaction processor for fabric +type NamespaceTxProcessor struct { + networkServiceProvider *fabric.NetworkServiceProvider +} + +// NewNamespaceTxProcessor returns a new instance of NamespaceTxProcessor +func NewNamespaceTxProcessor(networkServiceProvider *fabric.NetworkServiceProvider) *NamespaceTxProcessor { + return &NamespaceTxProcessor{networkServiceProvider: networkServiceProvider} +} + +// EnableTxProcessing signals the fabric committer to process all transactions in the network specified by the given tms id +func (n *NamespaceTxProcessor) EnableTxProcessing(tmsID token2.TMSID) error { + nw, err := n.networkServiceProvider.FabricNetworkService(tmsID.Network) + if err != nil { + return errors.WithMessagef(err, "failed getting fabric network service for [%s]", tmsID.Network) + } + ch, err := nw.Channel(tmsID.Channel) + if err != nil { + return errors.Wrapf(err, "failed getting channel [%s]", tmsID.Channel) + } + committer := ch.Committer() + logger.Debug("this node is an endorser, prepare it...") + // if I'm an endorser, I need to process all token transactions + if err := committer.ProcessNamespace(tmsID.Namespace); err != nil { + return errors.WithMessagef(err, "failed to add namespace to committer [%s]", tmsID.Namespace) + } + + return nil +} + +// EndorserService wraps the FSC's endorser service +type EndorserService struct { + tmsProvider *token2.ManagementServiceProvider + fabricProvider *fabric.NetworkServiceProvider +} + +// NewEndorserService returns a new instance of EndorserService +func NewEndorserService(tmsProvider *token2.ManagementServiceProvider, fabricProvider *fabric.NetworkServiceProvider) *EndorserService { + return &EndorserService{tmsProvider: tmsProvider, fabricProvider: fabricProvider} +} + +func (e *EndorserService) ReceiveTx(ctx view.Context) (*endorser.Transaction, error) { + _, tx, err := endorser.NewTransactionFromBytes(ctx, session.ReadFirstMessageOrPanic(ctx)) + if err != nil { + return nil, errors.WithMessagef(err, "failed to received transaction for approval") + } + return tx, nil +} + +func (e *EndorserService) Endorse(ctx view.Context, tx *endorser.Transaction, identities ...view.Identity) (any, error) { + return ctx.RunView(endorser.NewEndorsementOnProposalResponderView(tx, identities...)) +} + +func (e *EndorserService) NewTransaction(context view.Context, opts ...fabric.TransactionOption) (*endorser.Transaction, error) { + _, tx, err := endorser.NewTransaction(context, opts...) + return tx, err +} + +func (e *EndorserService) CollectEndorsements(ctx view.Context, tx *endorser.Transaction, timeOut time.Duration, endorsers ...view.Identity) error { + _, err := ctx.RunView(endorser.NewParallelCollectEndorsementsOnProposalView( + tx, + endorsers..., + ).WithTimeout(timeOut)) + return err +} + +func (e *EndorserService) EndorserID(tmsID token2.TMSID) (view.Identity, error) { + var endorserIDLabel string + tms, err := e.tmsProvider.GetManagementService(token2.WithTMSID(tmsID)) + if err != nil { + return nil, errors.WithMessagef(err, "failed getting management service for [%s]", tmsID) + } + if err := tms.Configuration().UnmarshalKey("services.network.fabric.fsc_endorsement.id", &endorserIDLabel); err != nil { + return nil, errors.WithMessagef(err, "failed to load endorserID") + } + fns, err := e.fabricProvider.FabricNetworkService(tmsID.Network) + if err != nil { + return nil, errors.WithMessagef(err, "cannot find fabric network for [%s]", tmsID.Network) + } + + var endorserID view.Identity + if len(endorserIDLabel) == 0 { + endorserID = fns.LocalMembership().DefaultIdentity() + } else { + var err error + endorserID, err = fns.LocalMembership().GetIdentityByID(endorserIDLabel) + if err != nil { + return nil, errors.WithMessagef(err, "cannot find local endorser identity for [%s]", endorserIDLabel) + } + } + if endorserID.IsNone() { + return nil, errors.Errorf("cannot find local endorser identity for [%s]", endorserIDLabel) + } + if _, err := fns.SignerService().GetSigner(endorserID); err != nil { + return nil, errors.WithMessagef(err, "cannot find fabric signer for identity [%s:%s]", endorserIDLabel, endorserID) + } + return endorserID, nil +} + +// StorageProvider wraps ttxdb.StoreServiceManager +type StorageProvider struct { + ttxdb.StoreServiceManager +} + +// NewStorageProvider returns a new instance of StorageProvider +func NewStorageProvider(storeServiceManager ttxdb.StoreServiceManager) *StorageProvider { + return &StorageProvider{StoreServiceManager: storeServiceManager} +} + +// GetStorage returns the fsc.Storage instance for the given tms id. +func (s *StorageProvider) GetStorage(id token2.TMSID) (fsc.Storage, error) { + return s.StoreServiceByTMSId(id) +} diff --git a/token/services/network/fabricx/driver.go b/token/services/network/fabricx/driver.go index 4770e4124..439016d55 100644 --- a/token/services/network/fabricx/driver.go +++ b/token/services/network/fabricx/driver.go @@ -23,6 +23,7 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/driver" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric" config3 "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/config" + endorsement2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/finality" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/lookup" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabricx/endorsement" @@ -31,6 +32,7 @@ import ( pp2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabricx/pp" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabricx/qe" "github.com/hyperledger-labs/fabric-token-sdk/token/services/tokens" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttxdb" "go.opentelemetry.io/otel/trace" ) @@ -46,6 +48,7 @@ func NewDriver( ppFetcher *pp2.PublicParametersService, configService driver2.ConfigService, qsProvider queryservice.Provider, + storeServiceManager ttxdb.StoreServiceManager, ) driver.Driver { vkp := pp2.NewVersionKeeperProvider() kt := &keys.Translator{} @@ -74,13 +77,15 @@ func NewDriver( config3.NewListenerManagerConfig(configService), ), EndorsementServiceProvider: endorsement.NewServiceProvider( - fnsProvider, configs, viewManager, viewManager, identityProvider, kt, vkp, + tmsProvider, + endorsement2.NewStorageProvider(storeServiceManager), + fnsProvider, ), setupListenerProvider: lookup2.NewSetupListenerProvider( tmsProvider, diff --git a/token/services/network/fabricx/endorsement/esp.go b/token/services/network/fabricx/endorsement/esp.go index d8c75faba..84237d815 100644 --- a/token/services/network/fabricx/endorsement/esp.go +++ b/token/services/network/fabricx/endorsement/esp.go @@ -17,7 +17,9 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/common" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/common/rws/translator" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabric/endorsement/fsc" "github.com/hyperledger-labs/fabric-token-sdk/token/services/network/fabricx/pp" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttxdb" ) type IdentityProvider interface { @@ -28,41 +30,47 @@ type ViewManager interface { InitiateView(view view.View, ctx context.Context) (interface{}, error) } -type ViewRegistry = endorsement.ViewRegistry +type ViewRegistry = fsc.ViewRegistry type ServiceProvider struct { lazy.Provider[token2.TMSID, endorsement.Service] } func NewServiceProvider( - fnsp *fabric.NetworkServiceProvider, configService common.Configuration, viewManager ViewManager, viewRegistry ViewRegistry, identityProvider IdentityProvider, keyTranslator translator.KeyTranslator, versionKeeperProvider pp.VersionKeeperProvider, + tokenManagementSystemProvider *token2.ManagementServiceProvider, + storeServiceManager ttxdb.StoreServiceManager, + fabricProvider *fabric.NetworkServiceProvider, ) *ServiceProvider { l := &loader{ - fnsp: fnsp, - configService: configService, - viewManager: viewManager, - viewRegistry: viewRegistry, - identityProvider: identityProvider, - keyTranslator: keyTranslator, - versionKeeperProvider: versionKeeperProvider, + configService: configService, + viewManager: viewManager, + viewRegistry: viewRegistry, + identityProvider: identityProvider, + keyTranslator: keyTranslator, + versionKeeperProvider: versionKeeperProvider, + tokenManagementSystemProvider: tokenManagementSystemProvider, + storeServiceManager: storeServiceManager, + fabricProvider: fabricProvider, } return &ServiceProvider{Provider: lazy.NewProviderWithKeyMapper(key, l.load)} } type loader struct { - fnsp *fabric.NetworkServiceProvider - configService common.Configuration - viewManager ViewManager - viewRegistry ViewRegistry - identityProvider IdentityProvider - keyTranslator translator.KeyTranslator - versionKeeperProvider pp.VersionKeeperProvider + configService common.Configuration + viewManager ViewManager + viewRegistry ViewRegistry + identityProvider IdentityProvider + keyTranslator translator.KeyTranslator + versionKeeperProvider pp.VersionKeeperProvider + storeServiceManager ttxdb.StoreServiceManager + tokenManagementSystemProvider *token2.ManagementServiceProvider + fabricProvider *fabric.NetworkServiceProvider } func (l *loader) load(tmsID token2.TMSID) (endorsement.Service, error) { @@ -74,24 +82,36 @@ func (l *loader) load(tmsID token2.TMSID) (endorsement.Service, error) { if err != nil { return nil, err } - return endorsement.NewFSCService( - l.fnsp, + return fsc.NewEndorsementService( + &NamespaceTxProcessor{}, tmsID, configuration, l.viewRegistry, l.viewManager, l.identityProvider, l.keyTranslator, - func(txID string, namespace string, rws *fabric.RWSet) (endorsement.Translator, error) { + func(txID string, namespace string, rws *fabric.RWSet) (fsc.Translator, error) { return translator.New( txID, NewRWSetWrapper(rws, namespace, txID, vk.GetVersion()), l.keyTranslator, ), nil }, + endorsement.NewEndorserService(l.tokenManagementSystemProvider, l.fabricProvider), + l.tokenManagementSystemProvider, + endorsement.NewStorageProvider(l.storeServiceManager), ) } func key(tmsID token2.TMSID) string { return tmsID.Network + tmsID.Channel + tmsID.Namespace } + +// NamespaceTxProcessor models a namespace transaction processor for fabric X +type NamespaceTxProcessor struct { +} + +// EnableTxProcessing does nothing because for FabricX the endorser is stateless +func (n *NamespaceTxProcessor) EnableTxProcessing(tmsID token2.TMSID) error { + return nil +} diff --git a/token/services/ttx/dep/tokenapi/tms.go b/token/services/ttx/dep/tokenapi/tms.go index 23c2c9a95..4eae7f50a 100644 --- a/token/services/ttx/dep/tokenapi/tms.go +++ b/token/services/ttx/dep/tokenapi/tms.go @@ -33,3 +33,24 @@ func NewMockedManagementService(t *testing.T, tmsID token.TMSID) *token.Manageme require.NoError(t, err) return res } + +// NewMockedManagementServiceWithValidation returns a mocked token.ManagementService and a validator +func NewMockedManagementServiceWithValidation(t *testing.T, tmsID token.TMSID) (*token.ManagementService, *mock.Validator) { + t.Helper() + tms := &mock.TokenManagerService{} + pp := &mock.PublicParameters{} + ppm := &mock.PublicParamsManager{} + ppm.PublicParametersReturns(pp) + tms.PublicParamsManagerReturns(ppm) + vp := &mock2.VaultProvider{} + vault := &mock.Vault{} + qe := &mock.QueryEngine{} + vault.QueryEngineReturns(qe) + vp.VaultReturns(vault, nil) + validator := &mock.Validator{} + tms.ValidatorReturns(validator, nil) + + res, err := token.NewManagementService(tmsID, tms, nil, vp, nil, nil) + require.NoError(t, err) + return res, validator +} diff --git a/token/tms.go b/token/tms.go index 023ee2e9c..c0fd5d223 100644 --- a/token/tms.go +++ b/token/tms.go @@ -223,7 +223,7 @@ func (t *ManagementService) init() error { } t.validator = &Validator{backend: validator} t.auth = &Authorization{Authorization: t.tms.Authorization()} - t.conf = &Configuration{cm: t.tms.Configuration()} + t.conf = NewConfiguration(t.tms.Configuration()) t.tokensService = &TokensService{ts: t.tms.TokensService(), tus: t.tms.TokensUpgradeService()} t.publicParametersManager = &PublicParametersManager{ ppm: t.tms.PublicParamsManager(),