From dc16776b6b565c234056e58c9efc0a73f9ff45dc Mon Sep 17 00:00:00 2001 From: frank Date: Fri, 6 Sep 2024 21:06:56 +0800 Subject: [PATCH 01/19] fix: re-add paraswap content --- .../decentralized/contract/paraswap/worker.go | 232 ++++ .../contract/paraswap/worker_test.go | 440 ++++++ .../contract/paraswap/abi/V5ParaSwap.abi | 1018 ++++++++++++++ .../ethereum/contract/paraswap/contract.go | 21 + .../contract/paraswap/contract_v5_paraswap.go | 1218 +++++++++++++++++ 5 files changed, 2929 insertions(+) create mode 100644 internal/engine/worker/decentralized/contract/paraswap/worker.go create mode 100644 internal/engine/worker/decentralized/contract/paraswap/worker_test.go create mode 100644 provider/ethereum/contract/paraswap/abi/V5ParaSwap.abi create mode 100644 provider/ethereum/contract/paraswap/contract.go create mode 100644 provider/ethereum/contract/paraswap/contract_v5_paraswap.go diff --git a/internal/engine/worker/decentralized/contract/paraswap/worker.go b/internal/engine/worker/decentralized/contract/paraswap/worker.go new file mode 100644 index 00000000..593d944c --- /dev/null +++ b/internal/engine/worker/decentralized/contract/paraswap/worker.go @@ -0,0 +1,232 @@ +package paraswap + +import ( + "context" + "fmt" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/rss3-network/node/config" + "github.com/rss3-network/node/internal/engine" + source "github.com/rss3-network/node/internal/engine/source/ethereum" + "github.com/rss3-network/node/provider/ethereum" + "github.com/rss3-network/node/provider/ethereum/contract" + "github.com/rss3-network/node/provider/ethereum/contract/paraswap" + "github.com/rss3-network/node/provider/ethereum/token" + "github.com/rss3-network/node/schema/worker/decentralized" + "github.com/rss3-network/protocol-go/schema" + activityx "github.com/rss3-network/protocol-go/schema/activity" + "github.com/rss3-network/protocol-go/schema/metadata" + "github.com/rss3-network/protocol-go/schema/network" + "github.com/rss3-network/protocol-go/schema/tag" + "github.com/rss3-network/protocol-go/schema/typex" + "github.com/samber/lo" + "github.com/shopspring/decimal" + "go.uber.org/zap" +) + +var _ engine.Worker = (*worker)(nil) + +type worker struct { + ethereumClient ethereum.Client + tokenClient token.Client + paraswapV5Filter *paraswap.V5ParaSwapFilterer +} + +func (w *worker) Name() string { + return decentralized.Paraswap.String() +} + +func (w *worker) Platform() string { + return decentralized.PlatformParaswap.String() +} + +func (w *worker) Network() []network.Network { + return []network.Network{ + network.Ethereum, + } +} + +func (w *worker) Tags() []tag.Tag { + return []tag.Tag{ + tag.Exchange, + } +} + +func (w *worker) Types() []schema.Type { + return []schema.Type{ + typex.ExchangeSwap, + } +} + +func (w *worker) Filter() engine.DataSourceFilter { + return &source.Filter{ + LogAddresses: []common.Address{ + paraswap.AddressV5ParaSwap, + paraswap.AddressV5ParaSwapBase, + }, + LogTopics: []common.Hash{ + paraswap.EventHashV3Swapped, + paraswap.EventHashV3Bought, + paraswap.EventHashSwappedDirect, + }, + } +} + +func (w *worker) Transform(ctx context.Context, task engine.Task) (*activityx.Activity, error) { + ethereumTask, ok := task.(*source.Task) + if !ok { + return nil, fmt.Errorf("invalid task type %T", task) + } + + activity, err := task.BuildActivity(activityx.WithActivityPlatform(w.Platform())) + if err != nil { + return nil, fmt.Errorf("build activity: %w", err) + } + + activity.Type = typex.ExchangeSwap + activity.Actions = w.transformSwapTransaction(ctx, ethereumTask) + + return activity, nil +} + +func (w *worker) transformSwapTransaction(ctx context.Context, ethereumTask *source.Task) (actions []*activityx.Action) { + for _, log := range ethereumTask.Receipt.Logs { + if len(log.Topics) == 0 { + continue + } + + var ( + buffer []*activityx.Action + err error + ) + + switch { + case w.matchV3SwappedLog(ethereumTask, log): + buffer, err = w.transformV3SwappedLog(ctx, ethereumTask, log) + case w.matchV3BoughtLog(ethereumTask, log): + buffer, err = w.transformV3BoughtLog(ctx, ethereumTask, log) + case w.matchSwappedDirectLog(ethereumTask, log): + buffer, err = w.transformSwappedDirectLog(ctx, ethereumTask, log) + default: + zap.L().Debug("unknown event", zap.String("worker", w.Name()), zap.String("task", ethereumTask.ID()), zap.Stringer("event", log.Topics[0])) + continue + } + + if err != nil { + zap.L().Warn("handle paraswap swap transaction", zap.Error(err), zap.String("worker", w.Name()), zap.String("task", ethereumTask.ID())) + continue + } + + actions = append(actions, buffer...) + } + + zap.L().Info("Processing task", zap.Any("task", ethereumTask)) + + return actions +} + +func (w *worker) matchV3SwappedLog(_ *source.Task, log *ethereum.Log) bool { + return contract.MatchEventHashes(log.Topics[0], paraswap.EventHashV3Swapped) && + contract.MatchAddresses(log.Address, paraswap.AddressV5ParaSwap, paraswap.AddressV5ParaSwapBase) +} + +func (w *worker) matchV3BoughtLog(_ *source.Task, log *ethereum.Log) bool { + return contract.MatchEventHashes(log.Topics[0], paraswap.EventHashV3Bought) && + contract.MatchAddresses(log.Address, paraswap.AddressV5ParaSwap, paraswap.AddressV5ParaSwapBase) +} + +func (w *worker) matchSwappedDirectLog(_ *source.Task, log *ethereum.Log) bool { + return contract.MatchEventHashes(log.Topics[0], paraswap.EventHashSwappedDirect) && + contract.MatchAddresses(log.Address, paraswap.AddressV5ParaSwap, paraswap.AddressV5ParaSwapBase) +} + +func (w *worker) transformV3SwappedLog(ctx context.Context, task *source.Task, log *ethereum.Log) ([]*activityx.Action, error) { + event, err := w.paraswapV5Filter.ParseSwappedV3(log.Export()) + if err != nil { + return nil, fmt.Errorf("parse SwappedV3 event: %w", err) + } + + action, err := w.buildExchangeSwapAction(ctx, task, event.Beneficiary, event.Beneficiary, event.SrcToken, event.DestToken, event.SrcAmount, event.ReceivedAmount) + if err != nil { + return nil, fmt.Errorf("build exchange swap action: %w", err) + } + + return []*activityx.Action{action}, nil +} + +func (w *worker) transformV3BoughtLog(ctx context.Context, task *source.Task, log *ethereum.Log) ([]*activityx.Action, error) { + event, err := w.paraswapV5Filter.ParseBoughtV3(log.Export()) + if err != nil { + return nil, fmt.Errorf("parse BoughtV3 event: %w", err) + } + + action, err := w.buildExchangeSwapAction(ctx, task, event.Beneficiary, event.Beneficiary, event.SrcToken, event.DestToken, event.SrcAmount, event.ReceivedAmount) + if err != nil { + return nil, fmt.Errorf("build exchange swap action: %w", err) + } + + return []*activityx.Action{action}, nil +} + +func (w *worker) transformSwappedDirectLog(ctx context.Context, task *source.Task, log *ethereum.Log) ([]*activityx.Action, error) { + event, err := w.paraswapV5Filter.ParseSwappedDirect(log.Export()) + if err != nil { + return nil, fmt.Errorf("parse SwappedDirect event: %w", err) + } + + action, err := w.buildExchangeSwapAction(ctx, task, event.Beneficiary, event.Beneficiary, event.SrcToken, event.DestToken, event.SrcAmount, event.ReceivedAmount) + if err != nil { + return nil, fmt.Errorf("build exchange swap action: %w", err) + } + + return []*activityx.Action{action}, nil +} + +func (w *worker) buildExchangeSwapAction(ctx context.Context, task *source.Task, sender, receiver common.Address, tokenIn, tokenOut common.Address, amountIn, amountOut *big.Int) (*activityx.Action, error) { + tokenInAddress := lo.Ternary(tokenIn != paraswap.AddressETH, &tokenIn, nil) + tokenOutAddress := lo.Ternary(tokenOut != paraswap.AddressETH, &tokenOut, nil) + + tokenInMetadata, err := w.tokenClient.Lookup(ctx, task.ChainID, tokenInAddress, nil, task.Header.Number) + if err != nil { + return nil, fmt.Errorf("lookup token in metadata: %w", err) + } + + tokenInMetadata.Value = lo.ToPtr(decimal.NewFromBigInt(amountIn, 0)) + + tokenOutMetadata, err := w.tokenClient.Lookup(ctx, task.ChainID, tokenOutAddress, nil, task.Header.Number) + if err != nil { + return nil, fmt.Errorf("lookup token out metadata: %w", err) + } + + tokenOutMetadata.Value = lo.ToPtr(decimal.NewFromBigInt(amountOut, 0)) + + action := activityx.Action{ + Type: typex.ExchangeSwap, + Platform: w.Platform(), + From: sender.String(), + To: receiver.String(), + Metadata: metadata.ExchangeSwap{ + From: *tokenInMetadata, + To: *tokenOutMetadata, + }, + } + + return &action, nil +} + +func NewWorker(config *config.Module) (engine.Worker, error) { + instance := worker{ + paraswapV5Filter: lo.Must(paraswap.NewV5ParaSwapFilterer(ethereum.AddressGenesis, nil)), + } + + var err error + + if instance.ethereumClient, err = ethereum.Dial(context.Background(), config.Endpoint.URL, config.Endpoint.BuildEthereumOptions()...); err != nil { + return nil, fmt.Errorf("initialize ethereum client: %w", err) + } + + instance.tokenClient = token.NewClient(instance.ethereumClient) + + return &instance, nil +} diff --git a/internal/engine/worker/decentralized/contract/paraswap/worker_test.go b/internal/engine/worker/decentralized/contract/paraswap/worker_test.go new file mode 100644 index 00000000..392587d1 --- /dev/null +++ b/internal/engine/worker/decentralized/contract/paraswap/worker_test.go @@ -0,0 +1,440 @@ +package paraswap_test + +import ( + "context" + "encoding/json" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/rss3-network/node/config" + source "github.com/rss3-network/node/internal/engine/source/ethereum" + worker "github.com/rss3-network/node/internal/engine/worker/decentralized/contract/paraswap" + "github.com/rss3-network/node/provider/ethereum" + "github.com/rss3-network/node/provider/ethereum/endpoint" + workerx "github.com/rss3-network/node/schema/worker/decentralized" + activityx "github.com/rss3-network/protocol-go/schema/activity" + "github.com/rss3-network/protocol-go/schema/metadata" + "github.com/rss3-network/protocol-go/schema/network" + "github.com/rss3-network/protocol-go/schema/typex" + "github.com/samber/lo" + "github.com/shopspring/decimal" + "github.com/stretchr/testify/require" +) + +func TestWorker_Paraswap(t *testing.T) { + t.Parallel() + + type arguments struct { + task *source.Task + config *config.Module + } + + testcases := []struct { + name string + arguments arguments + want *activityx.Activity + wantError require.ErrorAssertionFunc + }{ + { + name: "Paraswap Token Swap (REZ to ETH)", + arguments: struct { + task *source.Task + config *config.Module + }{ + task: &source.Task{ + Network: network.Ethereum, + ChainID: 1, + Header: ðereum.Header{ + Hash: common.HexToHash("0xa20374ef4f54e40ea0b12bea342d038217c1c52e9579f8784868422b8757619e"), + ParentHash: common.HexToHash("0xbc369c24220496d87af0ebddb713ad7fa96a6756088efd3289d99a0e03162cd3"), + UncleHash: common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"), + Coinbase: common.HexToAddress("0x1f9090aaE28b8a3dCeaDf281B0F12828e676c326"), + Number: lo.Must(new(big.Int).SetString("19771930", 0)), + GasLimit: 30000000, + GasUsed: 11600032, + Timestamp: 1714526063, + BaseFee: lo.Must(new(big.Int).SetString("6866994584", 0)), + Transactions: nil, + }, + Transaction: ðereum.Transaction{ + BlockHash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + From: common.HexToAddress("0x7c614681E6F6ECCa2E84D311D3f6dda6c460E55B"), + Gas: 306971, + GasPrice: lo.Must(new(big.Int).SetString("6956994584", 10)), + Hash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + Input: hexutil.MustDecode("0xa6886da900000000000000000000000000000000000000000000000000000000000000200000000000000000000000003b50805453023a91a8bf641e279401a0b23fa6f9000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564000000000000000000000000000000000000000000000052f103edb66ba80000000000000000000000000000000000000000000000000000010338174146251a0000000000000000000000000000000000000000000000000104858f02911c490100000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000006631ebc900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000002201704308b9f1748d39431ba15f2bedcc500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002b3b50805453023a91a8bf641e279401a0b23fa6f9000bb8c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000007c614681e6f6ecca2e84d311d3f6dda6c460e55b000000000000000000000000216b4b4ba9f3e719726886d34a177484278bfcae000000000000000000000000000000000000000000000052f103edb66ba800000000000000000000000000000000000000000000000000000000000066358bde000000000000000000000000000000000000000000000000000000000000001bdcd2799ac8a0174f1f44a3be56a31351b0fbfefb7620766293cfbec2f2343ff0653c54e08e4c433cd970a875c8eba3480fc58299d32e784ecbe541af4c451007"), + To: lo.ToPtr(common.HexToAddress("0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57")), + Value: lo.Must(new(big.Int).SetString("0", 0)), + Type: 2, + ChainID: lo.Must(new(big.Int).SetString("1", 0)), + }, + Receipt: ðereum.Receipt{ + BlockHash: common.HexToHash("0xa20374ef4f54e40ea0b12bea342d038217c1c52e9579f8784868422b8757619e"), + BlockNumber: lo.Must(new(big.Int).SetString("19771930", 0)), + ContractAddress: nil, + CumulativeGasUsed: 5998846, + EffectiveGasPrice: hexutil.MustDecodeBig("0x19eab5018"), + GasUsed: 200757, + + Logs: []*ethereum.Log{{ + Address: common.HexToAddress("0x3B50805453023a91a8bf641e279401a0b23FA6F9"), + Topics: []common.Hash{ + common.HexToHash("0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"), + common.HexToHash("0x0000000000000000000000007c614681e6f6ecca2e84d311d3f6dda6c460e55b"), + common.HexToHash("0x000000000000000000000000216b4b4ba9f3e719726886d34a177484278bfcae"), + }, + Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000052f103edb66ba80000"), + BlockNumber: lo.Must(new(big.Int).SetString("19771930", 0)), + TransactionHash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + Index: 160, + Removed: false, + }, { + Address: common.HexToAddress("0x3B50805453023a91a8bf641e279401a0b23FA6F9"), + Topics: []common.Hash{ + common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"), + common.HexToHash("0x0000000000000000000000007c614681e6f6ecca2e84d311d3f6dda6c460e55b"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + }, + Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000052f103edb66ba80000"), + BlockNumber: lo.Must(new(big.Int).SetString("19771930", 0)), + TransactionHash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + Index: 161, + Removed: false, + }, { + Address: common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), + Topics: []common.Hash{ + common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"), + common.HexToHash("0x00000000000000000000000059c68e0eca9f0844d9d4cee0bedf23c8dee462c5"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + }, + Data: hexutil.MustDecode("0x0000000000000000000000000000000000000000000000000104579503cdcadc"), + BlockNumber: lo.Must(new(big.Int).SetString("19771930", 0)), + TransactionHash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + Index: 162, + Removed: false, + }, { + Address: common.HexToAddress("0x3B50805453023a91a8bf641e279401a0b23FA6F9"), + Topics: []common.Hash{ + common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + common.HexToHash("0x00000000000000000000000059c68e0eca9f0844d9d4cee0bedf23c8dee462c5"), + }, + Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000052f103edb66ba80000"), + BlockNumber: lo.Must(new(big.Int).SetString("19771930", 0)), + TransactionHash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + Index: 163, + Removed: false, + }, { + Address: common.HexToAddress("0x59C68e0ECa9F0844d9D4CeE0BEDf23c8dEE462c5"), + Topics: []common.Hash{ + common.HexToHash("0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67"), + common.HexToHash("0x000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + }, + Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000052f103edb66ba80000fffffffffffffffffffffffffffffffffffffffffffffffffefba86afc323524000000000000000000000000000000000000000001c632f4c47ef9821f94f0b1000000000000000000000000000000000000000000000ef1fb85fa4e8dd48af1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe7b8e"), + BlockNumber: lo.Must(new(big.Int).SetString("19771930", 0)), + TransactionHash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + Index: 164, + Removed: false, + }, { + Address: common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), + Topics: []common.Hash{ + common.HexToHash("0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + }, + Data: hexutil.MustDecode("0x0000000000000000000000000000000000000000000000000104579503cdcadc"), + BlockNumber: lo.Must(new(big.Int).SetString("19771930", 0)), + TransactionHash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + Index: 165, + Removed: false, + }, { + Address: common.HexToAddress("0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57"), + Topics: []common.Hash{ + common.HexToHash("0xd2d73da2b5fd52cd654d8fd1b514ad57355bad741de639e3a1c3a20dd9f17347"), + common.HexToHash("0x0000000000000000000000007c614681e6f6ecca2e84d311d3f6dda6c460e55b"), + common.HexToHash("0x0000000000000000000000003b50805453023a91a8bf641e279401a0b23fa6f9"), + common.HexToHash("0x000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"), + }, + Data: hexutil.MustDecode("0x1704308b9f1748d39431ba15f2bedcc500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000040000000000000000000000000007c614681e6f6ecca2e84d311d3f6dda6c460e55b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000052f103edb66ba800000000000000000000000000000000000000000000000000000104579503cdcadc0000000000000000000000000000000000000000000000000104858f02911c49"), + BlockNumber: lo.Must(new(big.Int).SetString("19771930", 0)), + TransactionHash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + Index: 166, + Removed: false, + }}, + Status: 1, + TransactionHash: common.HexToHash("0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b"), + TransactionIndex: 71, + }, + }, + config: &config.Module{ + Network: network.Ethereum, + Endpoint: config.Endpoint{ + URL: endpoint.MustGet(network.Ethereum), + }, + }, + }, + want: &activityx.Activity{ + ID: "0x2c668402f39a485ef57cbfe31e24d7e0f9342a4584de7f94889fd7b02f90d77b", + Network: network.Ethereum, + Index: 71, + From: "0x7c614681E6F6ECCa2E84D311D3f6dda6c460E55B", + To: "0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57", + Type: typex.ExchangeSwap, + Platform: workerx.PlatformParaswap.String(), + Fee: &activityx.Fee{ + Amount: lo.Must(decimal.NewFromString("1396665361700088")), + Decimal: 18, + }, + Calldata: &activityx.Calldata{ + FunctionHash: "0xa6886da9", + }, + Actions: []*activityx.Action{ + { + Type: typex.ExchangeSwap, + Platform: workerx.PlatformParaswap.String(), + From: "0x7c614681E6F6ECCa2E84D311D3f6dda6c460E55B", + To: "0x7c614681E6F6ECCa2E84D311D3f6dda6c460E55B", + Metadata: metadata.ExchangeSwap{ + From: metadata.Token{ + Address: lo.ToPtr("0x3B50805453023a91a8bf641e279401a0b23FA6F9"), + Value: lo.ToPtr(lo.Must(decimal.NewFromString("1530000000000000000000"))), + Name: "Renzo", + Symbol: "REZ", + Decimals: 18, + Standard: metadata.StandardERC20, + }, + To: metadata.Token{ + Value: lo.ToPtr(lo.Must(decimal.NewFromString("73279791470332636"))), + Name: "Ethereum", + Symbol: "ETH", + Decimals: 18, + }, + }, + }, + }, + Status: true, + Timestamp: 1714526063, + }, + wantError: require.NoError, + }, + { + name: "Paraswap Token Swap (WETH to USDC)", + arguments: struct { + task *source.Task + config *config.Module + }{ + task: &source.Task{ + Network: network.Ethereum, + ChainID: 1, + Header: ðereum.Header{ + Hash: common.HexToHash("0x0e8ad5c0a8197420174e4622129960d4d9e551839eb0defab002c48b4f00b800"), + ParentHash: common.HexToHash("0x97206ab738d3f885446763cf64dc4b354e3781a3d044659cb9e8511885acb17b"), + UncleHash: common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"), + Coinbase: common.HexToAddress("0x95222290DD7278Aa3Ddd389Cc1E1d165CC4BAfe5"), + Number: lo.Must(new(big.Int).SetString("19771969", 0)), + GasLimit: 30000000, + GasUsed: 12027224, + Timestamp: 1714526531, + BaseFee: lo.Must(new(big.Int).SetString("6640967522", 0)), + Transactions: nil, + }, + Transaction: ðereum.Transaction{ + BlockHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + From: common.HexToAddress("0x47ed2b8a79f6D67dFD0C50313e260d07F5AC7E95"), + Gas: 2026878, + GasPrice: lo.Must(new(big.Int).SetString("6690967522", 10)), + Hash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + Input: hexutil.MustDecode("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"), + To: lo.ToPtr(common.HexToAddress("0xe6FC6A67607EFE4C44224c16be190980779F2dC1")), + Value: lo.Must(new(big.Int).SetString("0", 0)), + Type: 2, + ChainID: lo.Must(new(big.Int).SetString("1", 0)), + }, + Receipt: ðereum.Receipt{ + BlockHash: common.HexToHash("0x0e8ad5c0a8197420174e4622129960d4d9e551839eb0defab002c48b4f00b800"), + BlockNumber: lo.Must(new(big.Int).SetString("19771969", 0)), + ContractAddress: nil, + CumulativeGasUsed: 11301628, + EffectiveGasPrice: hexutil.MustDecodeBig("0x18ed00fe2"), + GasUsed: 999677, + + Logs: []*ethereum.Log{{ + Address: common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), + Topics: []common.Hash{ + common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"), + common.HexToHash("0x0000000000000000000000004d5f47fa6a74757f35c14fd3a6ef8e3c9bc514e8"), + common.HexToHash("0x0000000000000000000000006e5743e228614b000104b7d9b95d8981c92c26f0"), + }, + Data: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000026d6a0823aceefc0"), + BlockNumber: lo.Must(new(big.Int).SetString("19771969", 0)), + TransactionHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + Index: 262, + Removed: false, + }, { + Address: common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), + Topics: []common.Hash{ + common.HexToHash("0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"), + common.HexToHash("0x0000000000000000000000006e5743e228614b000104b7d9b95d8981c92c26f0"), + common.HexToHash("0x000000000000000000000000216b4b4ba9f3e719726886d34a177484278bfcae"), + }, + Data: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000026d6a0823aceefc0"), + BlockNumber: lo.Must(new(big.Int).SetString("19771969", 0)), + TransactionHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + Index: 263, + Removed: false, + }, { + Address: common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), + Topics: []common.Hash{ + common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"), + common.HexToHash("0x0000000000000000000000006e5743e228614b000104b7d9b95d8981c92c26f0"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + }, + Data: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000026d6a0823aceefc0"), + BlockNumber: lo.Must(new(big.Int).SetString("19771969", 0)), + TransactionHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + Index: 264, + Removed: false, + }, { + Address: common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"), + Topics: []common.Hash{ + common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"), + common.HexToHash("0x00000000000000000000000088e6a0c2ddd26feeb64f039a2c41296fcb3f5640"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + }, + Data: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000000000001f48502e5"), + BlockNumber: lo.Must(new(big.Int).SetString("19771969", 0)), + TransactionHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + Index: 265, + Removed: false, + }, { + Address: common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), + Topics: []common.Hash{ + common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + common.HexToHash("0x00000000000000000000000088e6a0c2ddd26feeb64f039a2c41296fcb3f5640"), + }, + Data: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000026d6a0823aceefc0"), + BlockNumber: lo.Must(new(big.Int).SetString("19771969", 0)), + TransactionHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + Index: 266, + Removed: false, + }, { + Address: common.HexToAddress("0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640"), + Topics: []common.Hash{ + common.HexToHash("0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67"), + common.HexToHash("0x000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + }, + Data: hexutil.MustDecode("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffe0b7afd1b00000000000000000000000000000000000000000000000026d6a0823aceefc0000000000000000000000000000000000000474b5fc02aca0c9606d9228e78f10000000000000000000000000000000000000000000000006e880344f151bb84000000000000000000000000000000000000000000000000000000000002fe99"), + BlockNumber: lo.Must(new(big.Int).SetString("19771969", 0)), + TransactionHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + Index: 267, + Removed: false, + }, { + Address: common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"), + Topics: []common.Hash{ + common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"), + common.HexToHash("0x000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57"), + common.HexToHash("0x0000000000000000000000006e5743e228614b000104b7d9b95d8981c92c26f0"), + }, + Data: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000000000001f48502e5"), + BlockNumber: lo.Must(new(big.Int).SetString("19771969", 0)), + TransactionHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + Index: 268, + Removed: false, + }, { + Address: common.HexToAddress("0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57"), + Topics: []common.Hash{ + common.HexToHash("0xd2d73da2b5fd52cd654d8fd1b514ad57355bad741de639e3a1c3a20dd9f17347"), + common.HexToHash("0x0000000000000000000000006e5743e228614b000104b7d9b95d8981c92c26f0"), + common.HexToHash("0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"), + common.HexToHash("0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"), + }, + Data: hexutil.MustDecode("0x1d0deb7b7778495c981e4402121ab77b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000040000000000000000000000000006e5743e228614b000104b7d9b95d8981c92c26f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026d6a0823aceefc000000000000000000000000000000000000000000000000000000001f48502e500000000000000000000000000000000000000000000000000000001f48502e5"), + BlockNumber: lo.Must(new(big.Int).SetString("19771969", 0)), + TransactionHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + Index: 269, + Removed: false, + }}, + Status: 1, + TransactionHash: common.HexToHash("0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b"), + TransactionIndex: 135, + }, + }, + config: &config.Module{ + Network: network.Ethereum, + Endpoint: config.Endpoint{ + URL: endpoint.MustGet(network.Ethereum), + }, + }, + }, + want: &activityx.Activity{ + ID: "0x647baef594b4acaab7e8e4e18a56d442b679a7e70d7b552da8250d675004176b", + Network: network.Ethereum, + Index: 135, + From: "0x47ed2b8a79f6D67dFD0C50313e260d07F5AC7E95", + To: "0xe6FC6A67607EFE4C44224c16be190980779F2dC1", + Type: typex.ExchangeSwap, + Platform: workerx.PlatformParaswap.String(), + Fee: &activityx.Fee{ + Amount: lo.Must(decimal.NewFromString("6688806339490394")), + Decimal: 18, + }, + Calldata: &activityx.Calldata{ + FunctionHash: "0x6092eae5", + }, + Actions: []*activityx.Action{ + { + Type: typex.ExchangeSwap, + Platform: workerx.PlatformParaswap.String(), + From: "0x6E5743E228614B000104b7D9B95d8981c92c26F0", + To: "0x6E5743E228614B000104b7D9B95d8981c92c26F0", + Metadata: metadata.ExchangeSwap{ + From: metadata.Token{ + Address: lo.ToPtr("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), + Value: lo.ToPtr(lo.Must(decimal.NewFromString("2798600699650174912"))), + Name: "Wrapped Ether", + Symbol: "WETH", + Decimals: 18, + Standard: metadata.StandardERC20, + }, + To: metadata.Token{ + Address: lo.ToPtr("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"), + Value: lo.ToPtr(lo.Must(decimal.NewFromString("8397325029"))), + Name: "USD Coin", + Symbol: "USDC", + Decimals: 6, + Standard: metadata.StandardERC20, + }, + }, + }, + }, + Status: true, + Timestamp: 1714526531, + }, + wantError: require.NoError, + }, + } + + for _, testcase := range testcases { + testcase := testcase + + t.Run(testcase.name, func(t *testing.T) { + t.Parallel() + + ctx := context.Background() + + instance, err := worker.NewWorker(testcase.arguments.config) + require.NoError(t, err) + + activity, err := instance.Transform(ctx, testcase.arguments.task) + testcase.wantError(t, err) + + t.Log(string(lo.Must(json.MarshalIndent(activity, "", "\x20\x20")))) + + require.Equal(t, testcase.want, activity) + }) + } +} diff --git a/provider/ethereum/contract/paraswap/abi/V5ParaSwap.abi b/provider/ethereum/contract/paraswap/abi/V5ParaSwap.abi new file mode 100644 index 00000000..874b02b7 --- /dev/null +++ b/provider/ethereum/contract/paraswap/abi/V5ParaSwap.abi @@ -0,0 +1,1018 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_weth", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_partnerSharePercent", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_maxFeePercent", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_paraswapReferralShare", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_paraswapSlippageShare", + "type": "uint256" + }, + { + "internalType": "contract IFeeClaimer", + "name": "_feeClaimer", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes16", + "name": "uuid", + "type": "bytes16" + }, + { + "indexed": false, + "internalType": "address", + "name": "partner", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "feePercent", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "initiator", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "beneficiary", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "srcToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "receivedAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "expectedAmount", + "type": "uint256" + } + ], + "name": "BoughtV3", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes16", + "name": "uuid", + "type": "bytes16" + }, + { + "indexed": false, + "internalType": "address", + "name": "partner", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "feePercent", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "initiator", + "type": "address" + }, + { + "indexed": false, + "internalType": "enum DirectSwap.DirectSwapKind", + "name": "kind", + "type": "uint8" + }, + { + "indexed": true, + "internalType": "address", + "name": "beneficiary", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "srcToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "receivedAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "expectedAmount", + "type": "uint256" + } + ], + "name": "SwappedDirect", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes16", + "name": "uuid", + "type": "bytes16" + }, + { + "indexed": false, + "internalType": "address", + "name": "partner", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "feePercent", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "initiator", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "beneficiary", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "srcToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "receivedAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "expectedAmount", + "type": "uint256" + } + ], + "name": "SwappedV3", + "type": "event" + }, + { + "inputs": [], + "name": "ROUTER_ROLE", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "WHITELISTED_ROLE", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "bytes32", + "name": "poolId", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "assetInIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "assetOutIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "userData", + "type": "bytes" + } + ], + "internalType": "struct IBalancerV2Vault.BatchSwapStep[]", + "name": "swaps", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "assets", + "type": "address[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "internalType": "bool", + "name": "fromInternalBalance", + "type": "bool" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + }, + { + "internalType": "bool", + "name": "toInternalBalance", + "type": "bool" + } + ], + "internalType": "struct IBalancerV2Vault.FundManagement", + "name": "funds", + "type": "tuple" + }, + { + "internalType": "int256[]", + "name": "limits", + "type": "int256[]" + }, + { + "internalType": "uint256", + "name": "fromAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "toAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "expectedAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "deadline", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "feePercent", + "type": "uint256" + }, + { + "internalType": "address", + "name": "vault", + "type": "address" + }, + { + "internalType": "address payable", + "name": "partner", + "type": "address" + }, + { + "internalType": "bool", + "name": "isApproved", + "type": "bool" + }, + { + "internalType": "address payable", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bytes", + "name": "permit", + "type": "bytes" + }, + { + "internalType": "bytes16", + "name": "uuid", + "type": "bytes16" + } + ], + "internalType": "struct Utils.DirectBalancerV2", + "name": "data", + "type": "tuple" + } + ], + "name": "directBalancerV2GivenInSwap", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "bytes32", + "name": "poolId", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "assetInIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "assetOutIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "userData", + "type": "bytes" + } + ], + "internalType": "struct IBalancerV2Vault.BatchSwapStep[]", + "name": "swaps", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "assets", + "type": "address[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "internalType": "bool", + "name": "fromInternalBalance", + "type": "bool" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + }, + { + "internalType": "bool", + "name": "toInternalBalance", + "type": "bool" + } + ], + "internalType": "struct IBalancerV2Vault.FundManagement", + "name": "funds", + "type": "tuple" + }, + { + "internalType": "int256[]", + "name": "limits", + "type": "int256[]" + }, + { + "internalType": "uint256", + "name": "fromAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "toAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "expectedAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "deadline", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "feePercent", + "type": "uint256" + }, + { + "internalType": "address", + "name": "vault", + "type": "address" + }, + { + "internalType": "address payable", + "name": "partner", + "type": "address" + }, + { + "internalType": "bool", + "name": "isApproved", + "type": "bool" + }, + { + "internalType": "address payable", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bytes", + "name": "permit", + "type": "bytes" + }, + { + "internalType": "bytes16", + "name": "uuid", + "type": "bytes16" + } + ], + "internalType": "struct Utils.DirectBalancerV2", + "name": "data", + "type": "tuple" + } + ], + "name": "directBalancerV2GivenOutSwap", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "fromToken", + "type": "address" + }, + { + "internalType": "address", + "name": "toToken", + "type": "address" + }, + { + "internalType": "address", + "name": "exchange", + "type": "address" + }, + { + "internalType": "uint256", + "name": "fromAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "toAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "expectedAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "feePercent", + "type": "uint256" + }, + { + "internalType": "int128", + "name": "i", + "type": "int128" + }, + { + "internalType": "int128", + "name": "j", + "type": "int128" + }, + { + "internalType": "address payable", + "name": "partner", + "type": "address" + }, + { + "internalType": "bool", + "name": "isApproved", + "type": "bool" + }, + { + "internalType": "enum Utils.CurveSwapType", + "name": "swapType", + "type": "uint8" + }, + { + "internalType": "address payable", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bool", + "name": "needWrapNative", + "type": "bool" + }, + { + "internalType": "bytes", + "name": "permit", + "type": "bytes" + }, + { + "internalType": "bytes16", + "name": "uuid", + "type": "bytes16" + } + ], + "internalType": "struct Utils.DirectCurveV1", + "name": "data", + "type": "tuple" + } + ], + "name": "directCurveV1Swap", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "fromToken", + "type": "address" + }, + { + "internalType": "address", + "name": "toToken", + "type": "address" + }, + { + "internalType": "address", + "name": "exchange", + "type": "address" + }, + { + "internalType": "address", + "name": "poolAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "fromAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "toAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "expectedAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "feePercent", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "i", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "j", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "partner", + "type": "address" + }, + { + "internalType": "bool", + "name": "isApproved", + "type": "bool" + }, + { + "internalType": "enum Utils.CurveSwapType", + "name": "swapType", + "type": "uint8" + }, + { + "internalType": "address payable", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bool", + "name": "needWrapNative", + "type": "bool" + }, + { + "internalType": "bytes", + "name": "permit", + "type": "bytes" + }, + { + "internalType": "bytes16", + "name": "uuid", + "type": "bytes16" + } + ], + "internalType": "struct Utils.DirectCurveV2", + "name": "data", + "type": "tuple" + } + ], + "name": "directCurveV2Swap", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "fromToken", + "type": "address" + }, + { + "internalType": "address", + "name": "toToken", + "type": "address" + }, + { + "internalType": "address", + "name": "exchange", + "type": "address" + }, + { + "internalType": "uint256", + "name": "fromAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "toAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "expectedAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "feePercent", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "deadline", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "partner", + "type": "address" + }, + { + "internalType": "bool", + "name": "isApproved", + "type": "bool" + }, + { + "internalType": "address payable", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bytes", + "name": "path", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "permit", + "type": "bytes" + }, + { + "internalType": "bytes16", + "name": "uuid", + "type": "bytes16" + } + ], + "internalType": "struct Utils.DirectUniV3", + "name": "data", + "type": "tuple" + } + ], + "name": "directUniV3Buy", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "fromToken", + "type": "address" + }, + { + "internalType": "address", + "name": "toToken", + "type": "address" + }, + { + "internalType": "address", + "name": "exchange", + "type": "address" + }, + { + "internalType": "uint256", + "name": "fromAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "toAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "expectedAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "feePercent", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "deadline", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "partner", + "type": "address" + }, + { + "internalType": "bool", + "name": "isApproved", + "type": "bool" + }, + { + "internalType": "address payable", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bytes", + "name": "path", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "permit", + "type": "bytes" + }, + { + "internalType": "bytes16", + "name": "uuid", + "type": "bytes16" + } + ], + "internalType": "struct Utils.DirectUniV3", + "name": "data", + "type": "tuple" + } + ], + "name": "directUniV3Swap", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [], + "name": "feeClaimer", + "outputs": [ + { + "internalType": "contract IFeeClaimer", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getKey", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [], + "name": "maxFeePercent", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "paraswapReferralShare", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "paraswapSlippageShare", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "partnerSharePercent", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "weth", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + } +] diff --git a/provider/ethereum/contract/paraswap/contract.go b/provider/ethereum/contract/paraswap/contract.go new file mode 100644 index 00000000..df5b661c --- /dev/null +++ b/provider/ethereum/contract/paraswap/contract.go @@ -0,0 +1,21 @@ +package paraswap + +import ( + "github.com/ethereum/go-ethereum/common" + "github.com/rss3-network/node/provider/ethereum/contract" +) + +// Paraswap V5 https://etherscan.io/address/0xdef171fe48cf0115b1d80b88dc8eab59176fee57 +//go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/V5ParaSwap.abi --pkg paraswap --type V5ParaSwap --out contract_v5_paraswap.go + +// https://developers.paraswap.network/smart-contracts +var ( + AddressV5ParaSwap = common.HexToAddress("0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57") + AddressV5ParaSwapBase = common.HexToAddress("0x59C7C832e96D2568bea6db468C1aAdcbbDa08A52") + + AddressETH = common.HexToAddress("0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE") + + EventHashV3Swapped = contract.EventHash("SwappedV3(bytes16,address,uint256,address,address,address,address,uint256,uint256,uint256)") + EventHashV3Bought = contract.EventHash("BoughtV3(bytes16,address,uint256,address,address,address,address,uint256,uint256,uint256)") + EventHashSwappedDirect = contract.EventHash("SwappedDirect(bytes16,address,uint256,address,uint8,address,address,address,uint256,uint256,uint256)") +) diff --git a/provider/ethereum/contract/paraswap/contract_v5_paraswap.go b/provider/ethereum/contract/paraswap/contract_v5_paraswap.go new file mode 100644 index 00000000..a9066238 --- /dev/null +++ b/provider/ethereum/contract/paraswap/contract_v5_paraswap.go @@ -0,0 +1,1218 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package paraswap + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IBalancerV2VaultBatchSwapStep is an auto generated low-level Go binding around an user-defined struct. +type IBalancerV2VaultBatchSwapStep struct { + PoolId [32]byte + AssetInIndex *big.Int + AssetOutIndex *big.Int + Amount *big.Int + UserData []byte +} + +// IBalancerV2VaultFundManagement is an auto generated low-level Go binding around an user-defined struct. +type IBalancerV2VaultFundManagement struct { + Sender common.Address + FromInternalBalance bool + Recipient common.Address + ToInternalBalance bool +} + +// UtilsDirectBalancerV2 is an auto generated low-level Go binding around an user-defined struct. +type UtilsDirectBalancerV2 struct { + Swaps []IBalancerV2VaultBatchSwapStep + Assets []common.Address + Funds IBalancerV2VaultFundManagement + Limits []*big.Int + FromAmount *big.Int + ToAmount *big.Int + ExpectedAmount *big.Int + Deadline *big.Int + FeePercent *big.Int + Vault common.Address + Partner common.Address + IsApproved bool + Beneficiary common.Address + Permit []byte + Uuid [16]byte +} + +// UtilsDirectCurveV1 is an auto generated low-level Go binding around an user-defined struct. +type UtilsDirectCurveV1 struct { + FromToken common.Address + ToToken common.Address + Exchange common.Address + FromAmount *big.Int + ToAmount *big.Int + ExpectedAmount *big.Int + FeePercent *big.Int + I *big.Int + J *big.Int + Partner common.Address + IsApproved bool + SwapType uint8 + Beneficiary common.Address + NeedWrapNative bool + Permit []byte + Uuid [16]byte +} + +// UtilsDirectCurveV2 is an auto generated low-level Go binding around an user-defined struct. +type UtilsDirectCurveV2 struct { + FromToken common.Address + ToToken common.Address + Exchange common.Address + PoolAddress common.Address + FromAmount *big.Int + ToAmount *big.Int + ExpectedAmount *big.Int + FeePercent *big.Int + I *big.Int + J *big.Int + Partner common.Address + IsApproved bool + SwapType uint8 + Beneficiary common.Address + NeedWrapNative bool + Permit []byte + Uuid [16]byte +} + +// UtilsDirectUniV3 is an auto generated low-level Go binding around an user-defined struct. +type UtilsDirectUniV3 struct { + FromToken common.Address + ToToken common.Address + Exchange common.Address + FromAmount *big.Int + ToAmount *big.Int + ExpectedAmount *big.Int + FeePercent *big.Int + Deadline *big.Int + Partner common.Address + IsApproved bool + Beneficiary common.Address + Path []byte + Permit []byte + Uuid [16]byte +} + +// V5ParaSwapMetaData contains all meta data concerning the V5ParaSwap contract. +var V5ParaSwapMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_weth\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_partnerSharePercent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_maxFeePercent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_paraswapReferralShare\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_paraswapSlippageShare\",\"type\":\"uint256\"},{\"internalType\":\"contractIFeeClaimer\",\"name\":\"_feeClaimer\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes16\",\"name\":\"uuid\",\"type\":\"bytes16\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"partner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"feePercent\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"srcToken\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"srcAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"receivedAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"expectedAmount\",\"type\":\"uint256\"}],\"name\":\"BoughtV3\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes16\",\"name\":\"uuid\",\"type\":\"bytes16\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"partner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"feePercent\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"enumDirectSwap.DirectSwapKind\",\"name\":\"kind\",\"type\":\"uint8\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"srcToken\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"srcAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"receivedAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"expectedAmount\",\"type\":\"uint256\"}],\"name\":\"SwappedDirect\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes16\",\"name\":\"uuid\",\"type\":\"bytes16\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"partner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"feePercent\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"srcToken\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"srcAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"receivedAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"expectedAmount\",\"type\":\"uint256\"}],\"name\":\"SwappedV3\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"ROUTER_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"WHITELISTED_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"poolId\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"assetInIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"assetOutIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"userData\",\"type\":\"bytes\"}],\"internalType\":\"structIBalancerV2Vault.BatchSwapStep[]\",\"name\":\"swaps\",\"type\":\"tuple[]\"},{\"internalType\":\"address[]\",\"name\":\"assets\",\"type\":\"address[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"fromInternalBalance\",\"type\":\"bool\"},{\"internalType\":\"addresspayable\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"toInternalBalance\",\"type\":\"bool\"}],\"internalType\":\"structIBalancerV2Vault.FundManagement\",\"name\":\"funds\",\"type\":\"tuple\"},{\"internalType\":\"int256[]\",\"name\":\"limits\",\"type\":\"int256[]\"},{\"internalType\":\"uint256\",\"name\":\"fromAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expectedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feePercent\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"addresspayable\",\"name\":\"partner\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"isApproved\",\"type\":\"bool\"},{\"internalType\":\"addresspayable\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"permit\",\"type\":\"bytes\"},{\"internalType\":\"bytes16\",\"name\":\"uuid\",\"type\":\"bytes16\"}],\"internalType\":\"structUtils.DirectBalancerV2\",\"name\":\"data\",\"type\":\"tuple\"}],\"name\":\"directBalancerV2GivenInSwap\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"poolId\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"assetInIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"assetOutIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"userData\",\"type\":\"bytes\"}],\"internalType\":\"structIBalancerV2Vault.BatchSwapStep[]\",\"name\":\"swaps\",\"type\":\"tuple[]\"},{\"internalType\":\"address[]\",\"name\":\"assets\",\"type\":\"address[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"fromInternalBalance\",\"type\":\"bool\"},{\"internalType\":\"addresspayable\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"toInternalBalance\",\"type\":\"bool\"}],\"internalType\":\"structIBalancerV2Vault.FundManagement\",\"name\":\"funds\",\"type\":\"tuple\"},{\"internalType\":\"int256[]\",\"name\":\"limits\",\"type\":\"int256[]\"},{\"internalType\":\"uint256\",\"name\":\"fromAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expectedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feePercent\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"addresspayable\",\"name\":\"partner\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"isApproved\",\"type\":\"bool\"},{\"internalType\":\"addresspayable\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"permit\",\"type\":\"bytes\"},{\"internalType\":\"bytes16\",\"name\":\"uuid\",\"type\":\"bytes16\"}],\"internalType\":\"structUtils.DirectBalancerV2\",\"name\":\"data\",\"type\":\"tuple\"}],\"name\":\"directBalancerV2GivenOutSwap\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"fromToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"toToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"exchange\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"fromAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expectedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feePercent\",\"type\":\"uint256\"},{\"internalType\":\"int128\",\"name\":\"i\",\"type\":\"int128\"},{\"internalType\":\"int128\",\"name\":\"j\",\"type\":\"int128\"},{\"internalType\":\"addresspayable\",\"name\":\"partner\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"isApproved\",\"type\":\"bool\"},{\"internalType\":\"enumUtils.CurveSwapType\",\"name\":\"swapType\",\"type\":\"uint8\"},{\"internalType\":\"addresspayable\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"needWrapNative\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"permit\",\"type\":\"bytes\"},{\"internalType\":\"bytes16\",\"name\":\"uuid\",\"type\":\"bytes16\"}],\"internalType\":\"structUtils.DirectCurveV1\",\"name\":\"data\",\"type\":\"tuple\"}],\"name\":\"directCurveV1Swap\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"fromToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"toToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"exchange\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"poolAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"fromAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expectedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feePercent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"i\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"j\",\"type\":\"uint256\"},{\"internalType\":\"addresspayable\",\"name\":\"partner\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"isApproved\",\"type\":\"bool\"},{\"internalType\":\"enumUtils.CurveSwapType\",\"name\":\"swapType\",\"type\":\"uint8\"},{\"internalType\":\"addresspayable\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"needWrapNative\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"permit\",\"type\":\"bytes\"},{\"internalType\":\"bytes16\",\"name\":\"uuid\",\"type\":\"bytes16\"}],\"internalType\":\"structUtils.DirectCurveV2\",\"name\":\"data\",\"type\":\"tuple\"}],\"name\":\"directCurveV2Swap\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"fromToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"toToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"exchange\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"fromAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expectedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feePercent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"addresspayable\",\"name\":\"partner\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"isApproved\",\"type\":\"bool\"},{\"internalType\":\"addresspayable\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"path\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"permit\",\"type\":\"bytes\"},{\"internalType\":\"bytes16\",\"name\":\"uuid\",\"type\":\"bytes16\"}],\"internalType\":\"structUtils.DirectUniV3\",\"name\":\"data\",\"type\":\"tuple\"}],\"name\":\"directUniV3Buy\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"fromToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"toToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"exchange\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"fromAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expectedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feePercent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"addresspayable\",\"name\":\"partner\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"isApproved\",\"type\":\"bool\"},{\"internalType\":\"addresspayable\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"path\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"permit\",\"type\":\"bytes\"},{\"internalType\":\"bytes16\",\"name\":\"uuid\",\"type\":\"bytes16\"}],\"internalType\":\"structUtils.DirectUniV3\",\"name\":\"data\",\"type\":\"tuple\"}],\"name\":\"directUniV3Swap\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"feeClaimer\",\"outputs\":[{\"internalType\":\"contractIFeeClaimer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getKey\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxFeePercent\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paraswapReferralShare\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paraswapSlippageShare\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"partnerSharePercent\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"weth\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// V5ParaSwapABI is the input ABI used to generate the binding from. +// Deprecated: Use V5ParaSwapMetaData.ABI instead. +var V5ParaSwapABI = V5ParaSwapMetaData.ABI + +// V5ParaSwap is an auto generated Go binding around an Ethereum contract. +type V5ParaSwap struct { + V5ParaSwapCaller // Read-only binding to the contract + V5ParaSwapTransactor // Write-only binding to the contract + V5ParaSwapFilterer // Log filterer for contract events +} + +// V5ParaSwapCaller is an auto generated read-only Go binding around an Ethereum contract. +type V5ParaSwapCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// V5ParaSwapTransactor is an auto generated write-only Go binding around an Ethereum contract. +type V5ParaSwapTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// V5ParaSwapFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type V5ParaSwapFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// V5ParaSwapSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type V5ParaSwapSession struct { + Contract *V5ParaSwap // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// V5ParaSwapCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type V5ParaSwapCallerSession struct { + Contract *V5ParaSwapCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// V5ParaSwapTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type V5ParaSwapTransactorSession struct { + Contract *V5ParaSwapTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// V5ParaSwapRaw is an auto generated low-level Go binding around an Ethereum contract. +type V5ParaSwapRaw struct { + Contract *V5ParaSwap // Generic contract binding to access the raw methods on +} + +// V5ParaSwapCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type V5ParaSwapCallerRaw struct { + Contract *V5ParaSwapCaller // Generic read-only contract binding to access the raw methods on +} + +// V5ParaSwapTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type V5ParaSwapTransactorRaw struct { + Contract *V5ParaSwapTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewV5ParaSwap creates a new instance of V5ParaSwap, bound to a specific deployed contract. +func NewV5ParaSwap(address common.Address, backend bind.ContractBackend) (*V5ParaSwap, error) { + contract, err := bindV5ParaSwap(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &V5ParaSwap{V5ParaSwapCaller: V5ParaSwapCaller{contract: contract}, V5ParaSwapTransactor: V5ParaSwapTransactor{contract: contract}, V5ParaSwapFilterer: V5ParaSwapFilterer{contract: contract}}, nil +} + +// NewV5ParaSwapCaller creates a new read-only instance of V5ParaSwap, bound to a specific deployed contract. +func NewV5ParaSwapCaller(address common.Address, caller bind.ContractCaller) (*V5ParaSwapCaller, error) { + contract, err := bindV5ParaSwap(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &V5ParaSwapCaller{contract: contract}, nil +} + +// NewV5ParaSwapTransactor creates a new write-only instance of V5ParaSwap, bound to a specific deployed contract. +func NewV5ParaSwapTransactor(address common.Address, transactor bind.ContractTransactor) (*V5ParaSwapTransactor, error) { + contract, err := bindV5ParaSwap(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &V5ParaSwapTransactor{contract: contract}, nil +} + +// NewV5ParaSwapFilterer creates a new log filterer instance of V5ParaSwap, bound to a specific deployed contract. +func NewV5ParaSwapFilterer(address common.Address, filterer bind.ContractFilterer) (*V5ParaSwapFilterer, error) { + contract, err := bindV5ParaSwap(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &V5ParaSwapFilterer{contract: contract}, nil +} + +// bindV5ParaSwap binds a generic wrapper to an already deployed contract. +func bindV5ParaSwap(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := V5ParaSwapMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_V5ParaSwap *V5ParaSwapRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _V5ParaSwap.Contract.V5ParaSwapCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_V5ParaSwap *V5ParaSwapRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _V5ParaSwap.Contract.V5ParaSwapTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_V5ParaSwap *V5ParaSwapRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _V5ParaSwap.Contract.V5ParaSwapTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_V5ParaSwap *V5ParaSwapCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _V5ParaSwap.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_V5ParaSwap *V5ParaSwapTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _V5ParaSwap.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_V5ParaSwap *V5ParaSwapTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _V5ParaSwap.Contract.contract.Transact(opts, method, params...) +} + +// ROUTERROLE is a free data retrieval call binding the contract method 0x30d643b5. +// +// Solidity: function ROUTER_ROLE() view returns(bytes32) +func (_V5ParaSwap *V5ParaSwapCaller) ROUTERROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "ROUTER_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ROUTERROLE is a free data retrieval call binding the contract method 0x30d643b5. +// +// Solidity: function ROUTER_ROLE() view returns(bytes32) +func (_V5ParaSwap *V5ParaSwapSession) ROUTERROLE() ([32]byte, error) { + return _V5ParaSwap.Contract.ROUTERROLE(&_V5ParaSwap.CallOpts) +} + +// ROUTERROLE is a free data retrieval call binding the contract method 0x30d643b5. +// +// Solidity: function ROUTER_ROLE() view returns(bytes32) +func (_V5ParaSwap *V5ParaSwapCallerSession) ROUTERROLE() ([32]byte, error) { + return _V5ParaSwap.Contract.ROUTERROLE(&_V5ParaSwap.CallOpts) +} + +// WHITELISTEDROLE is a free data retrieval call binding the contract method 0x7a3226ec. +// +// Solidity: function WHITELISTED_ROLE() view returns(bytes32) +func (_V5ParaSwap *V5ParaSwapCaller) WHITELISTEDROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "WHITELISTED_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// WHITELISTEDROLE is a free data retrieval call binding the contract method 0x7a3226ec. +// +// Solidity: function WHITELISTED_ROLE() view returns(bytes32) +func (_V5ParaSwap *V5ParaSwapSession) WHITELISTEDROLE() ([32]byte, error) { + return _V5ParaSwap.Contract.WHITELISTEDROLE(&_V5ParaSwap.CallOpts) +} + +// WHITELISTEDROLE is a free data retrieval call binding the contract method 0x7a3226ec. +// +// Solidity: function WHITELISTED_ROLE() view returns(bytes32) +func (_V5ParaSwap *V5ParaSwapCallerSession) WHITELISTEDROLE() ([32]byte, error) { + return _V5ParaSwap.Contract.WHITELISTEDROLE(&_V5ParaSwap.CallOpts) +} + +// FeeClaimer is a free data retrieval call binding the contract method 0x81cbd3ea. +// +// Solidity: function feeClaimer() view returns(address) +func (_V5ParaSwap *V5ParaSwapCaller) FeeClaimer(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "feeClaimer") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// FeeClaimer is a free data retrieval call binding the contract method 0x81cbd3ea. +// +// Solidity: function feeClaimer() view returns(address) +func (_V5ParaSwap *V5ParaSwapSession) FeeClaimer() (common.Address, error) { + return _V5ParaSwap.Contract.FeeClaimer(&_V5ParaSwap.CallOpts) +} + +// FeeClaimer is a free data retrieval call binding the contract method 0x81cbd3ea. +// +// Solidity: function feeClaimer() view returns(address) +func (_V5ParaSwap *V5ParaSwapCallerSession) FeeClaimer() (common.Address, error) { + return _V5ParaSwap.Contract.FeeClaimer(&_V5ParaSwap.CallOpts) +} + +// GetKey is a free data retrieval call binding the contract method 0x82678dd6. +// +// Solidity: function getKey() pure returns(bytes32) +func (_V5ParaSwap *V5ParaSwapCaller) GetKey(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "getKey") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetKey is a free data retrieval call binding the contract method 0x82678dd6. +// +// Solidity: function getKey() pure returns(bytes32) +func (_V5ParaSwap *V5ParaSwapSession) GetKey() ([32]byte, error) { + return _V5ParaSwap.Contract.GetKey(&_V5ParaSwap.CallOpts) +} + +// GetKey is a free data retrieval call binding the contract method 0x82678dd6. +// +// Solidity: function getKey() pure returns(bytes32) +func (_V5ParaSwap *V5ParaSwapCallerSession) GetKey() ([32]byte, error) { + return _V5ParaSwap.Contract.GetKey(&_V5ParaSwap.CallOpts) +} + +// Initialize is a free data retrieval call binding the contract method 0x439fab91. +// +// Solidity: function initialize(bytes ) pure returns() +func (_V5ParaSwap *V5ParaSwapCaller) Initialize(opts *bind.CallOpts, arg0 []byte) error { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "initialize", arg0) + + if err != nil { + return err + } + + return err + +} + +// Initialize is a free data retrieval call binding the contract method 0x439fab91. +// +// Solidity: function initialize(bytes ) pure returns() +func (_V5ParaSwap *V5ParaSwapSession) Initialize(arg0 []byte) error { + return _V5ParaSwap.Contract.Initialize(&_V5ParaSwap.CallOpts, arg0) +} + +// Initialize is a free data retrieval call binding the contract method 0x439fab91. +// +// Solidity: function initialize(bytes ) pure returns() +func (_V5ParaSwap *V5ParaSwapCallerSession) Initialize(arg0 []byte) error { + return _V5ParaSwap.Contract.Initialize(&_V5ParaSwap.CallOpts, arg0) +} + +// MaxFeePercent is a free data retrieval call binding the contract method 0xd830a05b. +// +// Solidity: function maxFeePercent() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapCaller) MaxFeePercent(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "maxFeePercent") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MaxFeePercent is a free data retrieval call binding the contract method 0xd830a05b. +// +// Solidity: function maxFeePercent() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapSession) MaxFeePercent() (*big.Int, error) { + return _V5ParaSwap.Contract.MaxFeePercent(&_V5ParaSwap.CallOpts) +} + +// MaxFeePercent is a free data retrieval call binding the contract method 0xd830a05b. +// +// Solidity: function maxFeePercent() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapCallerSession) MaxFeePercent() (*big.Int, error) { + return _V5ParaSwap.Contract.MaxFeePercent(&_V5ParaSwap.CallOpts) +} + +// ParaswapReferralShare is a free data retrieval call binding the contract method 0xd555d4f9. +// +// Solidity: function paraswapReferralShare() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapCaller) ParaswapReferralShare(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "paraswapReferralShare") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParaswapReferralShare is a free data retrieval call binding the contract method 0xd555d4f9. +// +// Solidity: function paraswapReferralShare() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapSession) ParaswapReferralShare() (*big.Int, error) { + return _V5ParaSwap.Contract.ParaswapReferralShare(&_V5ParaSwap.CallOpts) +} + +// ParaswapReferralShare is a free data retrieval call binding the contract method 0xd555d4f9. +// +// Solidity: function paraswapReferralShare() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapCallerSession) ParaswapReferralShare() (*big.Int, error) { + return _V5ParaSwap.Contract.ParaswapReferralShare(&_V5ParaSwap.CallOpts) +} + +// ParaswapSlippageShare is a free data retrieval call binding the contract method 0xc25ff026. +// +// Solidity: function paraswapSlippageShare() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapCaller) ParaswapSlippageShare(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "paraswapSlippageShare") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParaswapSlippageShare is a free data retrieval call binding the contract method 0xc25ff026. +// +// Solidity: function paraswapSlippageShare() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapSession) ParaswapSlippageShare() (*big.Int, error) { + return _V5ParaSwap.Contract.ParaswapSlippageShare(&_V5ParaSwap.CallOpts) +} + +// ParaswapSlippageShare is a free data retrieval call binding the contract method 0xc25ff026. +// +// Solidity: function paraswapSlippageShare() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapCallerSession) ParaswapSlippageShare() (*big.Int, error) { + return _V5ParaSwap.Contract.ParaswapSlippageShare(&_V5ParaSwap.CallOpts) +} + +// PartnerSharePercent is a free data retrieval call binding the contract method 0x12070a41. +// +// Solidity: function partnerSharePercent() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapCaller) PartnerSharePercent(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "partnerSharePercent") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PartnerSharePercent is a free data retrieval call binding the contract method 0x12070a41. +// +// Solidity: function partnerSharePercent() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapSession) PartnerSharePercent() (*big.Int, error) { + return _V5ParaSwap.Contract.PartnerSharePercent(&_V5ParaSwap.CallOpts) +} + +// PartnerSharePercent is a free data retrieval call binding the contract method 0x12070a41. +// +// Solidity: function partnerSharePercent() view returns(uint256) +func (_V5ParaSwap *V5ParaSwapCallerSession) PartnerSharePercent() (*big.Int, error) { + return _V5ParaSwap.Contract.PartnerSharePercent(&_V5ParaSwap.CallOpts) +} + +// Weth is a free data retrieval call binding the contract method 0x3fc8cef3. +// +// Solidity: function weth() view returns(address) +func (_V5ParaSwap *V5ParaSwapCaller) Weth(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _V5ParaSwap.contract.Call(opts, &out, "weth") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Weth is a free data retrieval call binding the contract method 0x3fc8cef3. +// +// Solidity: function weth() view returns(address) +func (_V5ParaSwap *V5ParaSwapSession) Weth() (common.Address, error) { + return _V5ParaSwap.Contract.Weth(&_V5ParaSwap.CallOpts) +} + +// Weth is a free data retrieval call binding the contract method 0x3fc8cef3. +// +// Solidity: function weth() view returns(address) +func (_V5ParaSwap *V5ParaSwapCallerSession) Weth() (common.Address, error) { + return _V5ParaSwap.Contract.Weth(&_V5ParaSwap.CallOpts) +} + +// DirectBalancerV2GivenInSwap is a paid mutator transaction binding the contract method 0xb22f4db8. +// +// Solidity: function directBalancerV2GivenInSwap(((bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256,uint256,uint256,uint256,uint256,address,address,bool,address,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactor) DirectBalancerV2GivenInSwap(opts *bind.TransactOpts, data UtilsDirectBalancerV2) (*types.Transaction, error) { + return _V5ParaSwap.contract.Transact(opts, "directBalancerV2GivenInSwap", data) +} + +// DirectBalancerV2GivenInSwap is a paid mutator transaction binding the contract method 0xb22f4db8. +// +// Solidity: function directBalancerV2GivenInSwap(((bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256,uint256,uint256,uint256,uint256,address,address,bool,address,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapSession) DirectBalancerV2GivenInSwap(data UtilsDirectBalancerV2) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectBalancerV2GivenInSwap(&_V5ParaSwap.TransactOpts, data) +} + +// DirectBalancerV2GivenInSwap is a paid mutator transaction binding the contract method 0xb22f4db8. +// +// Solidity: function directBalancerV2GivenInSwap(((bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256,uint256,uint256,uint256,uint256,address,address,bool,address,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactorSession) DirectBalancerV2GivenInSwap(data UtilsDirectBalancerV2) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectBalancerV2GivenInSwap(&_V5ParaSwap.TransactOpts, data) +} + +// DirectBalancerV2GivenOutSwap is a paid mutator transaction binding the contract method 0x19fc5be0. +// +// Solidity: function directBalancerV2GivenOutSwap(((bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256,uint256,uint256,uint256,uint256,address,address,bool,address,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactor) DirectBalancerV2GivenOutSwap(opts *bind.TransactOpts, data UtilsDirectBalancerV2) (*types.Transaction, error) { + return _V5ParaSwap.contract.Transact(opts, "directBalancerV2GivenOutSwap", data) +} + +// DirectBalancerV2GivenOutSwap is a paid mutator transaction binding the contract method 0x19fc5be0. +// +// Solidity: function directBalancerV2GivenOutSwap(((bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256,uint256,uint256,uint256,uint256,address,address,bool,address,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapSession) DirectBalancerV2GivenOutSwap(data UtilsDirectBalancerV2) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectBalancerV2GivenOutSwap(&_V5ParaSwap.TransactOpts, data) +} + +// DirectBalancerV2GivenOutSwap is a paid mutator transaction binding the contract method 0x19fc5be0. +// +// Solidity: function directBalancerV2GivenOutSwap(((bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256,uint256,uint256,uint256,uint256,address,address,bool,address,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactorSession) DirectBalancerV2GivenOutSwap(data UtilsDirectBalancerV2) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectBalancerV2GivenOutSwap(&_V5ParaSwap.TransactOpts, data) +} + +// DirectCurveV1Swap is a paid mutator transaction binding the contract method 0x3865bde6. +// +// Solidity: function directCurveV1Swap((address,address,address,uint256,uint256,uint256,uint256,int128,int128,address,bool,uint8,address,bool,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactor) DirectCurveV1Swap(opts *bind.TransactOpts, data UtilsDirectCurveV1) (*types.Transaction, error) { + return _V5ParaSwap.contract.Transact(opts, "directCurveV1Swap", data) +} + +// DirectCurveV1Swap is a paid mutator transaction binding the contract method 0x3865bde6. +// +// Solidity: function directCurveV1Swap((address,address,address,uint256,uint256,uint256,uint256,int128,int128,address,bool,uint8,address,bool,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapSession) DirectCurveV1Swap(data UtilsDirectCurveV1) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectCurveV1Swap(&_V5ParaSwap.TransactOpts, data) +} + +// DirectCurveV1Swap is a paid mutator transaction binding the contract method 0x3865bde6. +// +// Solidity: function directCurveV1Swap((address,address,address,uint256,uint256,uint256,uint256,int128,int128,address,bool,uint8,address,bool,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactorSession) DirectCurveV1Swap(data UtilsDirectCurveV1) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectCurveV1Swap(&_V5ParaSwap.TransactOpts, data) +} + +// DirectCurveV2Swap is a paid mutator transaction binding the contract method 0x58f15100. +// +// Solidity: function directCurveV2Swap((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,address,bool,uint8,address,bool,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactor) DirectCurveV2Swap(opts *bind.TransactOpts, data UtilsDirectCurveV2) (*types.Transaction, error) { + return _V5ParaSwap.contract.Transact(opts, "directCurveV2Swap", data) +} + +// DirectCurveV2Swap is a paid mutator transaction binding the contract method 0x58f15100. +// +// Solidity: function directCurveV2Swap((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,address,bool,uint8,address,bool,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapSession) DirectCurveV2Swap(data UtilsDirectCurveV2) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectCurveV2Swap(&_V5ParaSwap.TransactOpts, data) +} + +// DirectCurveV2Swap is a paid mutator transaction binding the contract method 0x58f15100. +// +// Solidity: function directCurveV2Swap((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,address,bool,uint8,address,bool,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactorSession) DirectCurveV2Swap(data UtilsDirectCurveV2) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectCurveV2Swap(&_V5ParaSwap.TransactOpts, data) +} + +// DirectUniV3Buy is a paid mutator transaction binding the contract method 0x87a63926. +// +// Solidity: function directUniV3Buy((address,address,address,uint256,uint256,uint256,uint256,uint256,address,bool,address,bytes,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactor) DirectUniV3Buy(opts *bind.TransactOpts, data UtilsDirectUniV3) (*types.Transaction, error) { + return _V5ParaSwap.contract.Transact(opts, "directUniV3Buy", data) +} + +// DirectUniV3Buy is a paid mutator transaction binding the contract method 0x87a63926. +// +// Solidity: function directUniV3Buy((address,address,address,uint256,uint256,uint256,uint256,uint256,address,bool,address,bytes,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapSession) DirectUniV3Buy(data UtilsDirectUniV3) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectUniV3Buy(&_V5ParaSwap.TransactOpts, data) +} + +// DirectUniV3Buy is a paid mutator transaction binding the contract method 0x87a63926. +// +// Solidity: function directUniV3Buy((address,address,address,uint256,uint256,uint256,uint256,uint256,address,bool,address,bytes,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactorSession) DirectUniV3Buy(data UtilsDirectUniV3) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectUniV3Buy(&_V5ParaSwap.TransactOpts, data) +} + +// DirectUniV3Swap is a paid mutator transaction binding the contract method 0xa6886da9. +// +// Solidity: function directUniV3Swap((address,address,address,uint256,uint256,uint256,uint256,uint256,address,bool,address,bytes,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactor) DirectUniV3Swap(opts *bind.TransactOpts, data UtilsDirectUniV3) (*types.Transaction, error) { + return _V5ParaSwap.contract.Transact(opts, "directUniV3Swap", data) +} + +// DirectUniV3Swap is a paid mutator transaction binding the contract method 0xa6886da9. +// +// Solidity: function directUniV3Swap((address,address,address,uint256,uint256,uint256,uint256,uint256,address,bool,address,bytes,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapSession) DirectUniV3Swap(data UtilsDirectUniV3) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectUniV3Swap(&_V5ParaSwap.TransactOpts, data) +} + +// DirectUniV3Swap is a paid mutator transaction binding the contract method 0xa6886da9. +// +// Solidity: function directUniV3Swap((address,address,address,uint256,uint256,uint256,uint256,uint256,address,bool,address,bytes,bytes,bytes16) data) payable returns() +func (_V5ParaSwap *V5ParaSwapTransactorSession) DirectUniV3Swap(data UtilsDirectUniV3) (*types.Transaction, error) { + return _V5ParaSwap.Contract.DirectUniV3Swap(&_V5ParaSwap.TransactOpts, data) +} + +// V5ParaSwapBoughtV3Iterator is returned from FilterBoughtV3 and is used to iterate over the raw logs and unpacked data for BoughtV3 events raised by the V5ParaSwap contract. +type V5ParaSwapBoughtV3Iterator struct { + Event *V5ParaSwapBoughtV3 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *V5ParaSwapBoughtV3Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(V5ParaSwapBoughtV3) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(V5ParaSwapBoughtV3) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *V5ParaSwapBoughtV3Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *V5ParaSwapBoughtV3Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// V5ParaSwapBoughtV3 represents a BoughtV3 event raised by the V5ParaSwap contract. +type V5ParaSwapBoughtV3 struct { + Uuid [16]byte + Partner common.Address + FeePercent *big.Int + Initiator common.Address + Beneficiary common.Address + SrcToken common.Address + DestToken common.Address + SrcAmount *big.Int + ReceivedAmount *big.Int + ExpectedAmount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBoughtV3 is a free log retrieval operation binding the contract event 0x4cc7e95e48af62690313a0733e93308ac9a73326bc3c29f1788b1191c376d5b6. +// +// Solidity: event BoughtV3(bytes16 uuid, address partner, uint256 feePercent, address initiator, address indexed beneficiary, address indexed srcToken, address indexed destToken, uint256 srcAmount, uint256 receivedAmount, uint256 expectedAmount) +func (_V5ParaSwap *V5ParaSwapFilterer) FilterBoughtV3(opts *bind.FilterOpts, beneficiary []common.Address, srcToken []common.Address, destToken []common.Address) (*V5ParaSwapBoughtV3Iterator, error) { + + var beneficiaryRule []interface{} + for _, beneficiaryItem := range beneficiary { + beneficiaryRule = append(beneficiaryRule, beneficiaryItem) + } + var srcTokenRule []interface{} + for _, srcTokenItem := range srcToken { + srcTokenRule = append(srcTokenRule, srcTokenItem) + } + var destTokenRule []interface{} + for _, destTokenItem := range destToken { + destTokenRule = append(destTokenRule, destTokenItem) + } + + logs, sub, err := _V5ParaSwap.contract.FilterLogs(opts, "BoughtV3", beneficiaryRule, srcTokenRule, destTokenRule) + if err != nil { + return nil, err + } + return &V5ParaSwapBoughtV3Iterator{contract: _V5ParaSwap.contract, event: "BoughtV3", logs: logs, sub: sub}, nil +} + +// WatchBoughtV3 is a free log subscription operation binding the contract event 0x4cc7e95e48af62690313a0733e93308ac9a73326bc3c29f1788b1191c376d5b6. +// +// Solidity: event BoughtV3(bytes16 uuid, address partner, uint256 feePercent, address initiator, address indexed beneficiary, address indexed srcToken, address indexed destToken, uint256 srcAmount, uint256 receivedAmount, uint256 expectedAmount) +func (_V5ParaSwap *V5ParaSwapFilterer) WatchBoughtV3(opts *bind.WatchOpts, sink chan<- *V5ParaSwapBoughtV3, beneficiary []common.Address, srcToken []common.Address, destToken []common.Address) (event.Subscription, error) { + + var beneficiaryRule []interface{} + for _, beneficiaryItem := range beneficiary { + beneficiaryRule = append(beneficiaryRule, beneficiaryItem) + } + var srcTokenRule []interface{} + for _, srcTokenItem := range srcToken { + srcTokenRule = append(srcTokenRule, srcTokenItem) + } + var destTokenRule []interface{} + for _, destTokenItem := range destToken { + destTokenRule = append(destTokenRule, destTokenItem) + } + + logs, sub, err := _V5ParaSwap.contract.WatchLogs(opts, "BoughtV3", beneficiaryRule, srcTokenRule, destTokenRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(V5ParaSwapBoughtV3) + if err := _V5ParaSwap.contract.UnpackLog(event, "BoughtV3", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBoughtV3 is a log parse operation binding the contract event 0x4cc7e95e48af62690313a0733e93308ac9a73326bc3c29f1788b1191c376d5b6. +// +// Solidity: event BoughtV3(bytes16 uuid, address partner, uint256 feePercent, address initiator, address indexed beneficiary, address indexed srcToken, address indexed destToken, uint256 srcAmount, uint256 receivedAmount, uint256 expectedAmount) +func (_V5ParaSwap *V5ParaSwapFilterer) ParseBoughtV3(log types.Log) (*V5ParaSwapBoughtV3, error) { + event := new(V5ParaSwapBoughtV3) + if err := _V5ParaSwap.contract.UnpackLog(event, "BoughtV3", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// V5ParaSwapSwappedDirectIterator is returned from FilterSwappedDirect and is used to iterate over the raw logs and unpacked data for SwappedDirect events raised by the V5ParaSwap contract. +type V5ParaSwapSwappedDirectIterator struct { + Event *V5ParaSwapSwappedDirect // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *V5ParaSwapSwappedDirectIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(V5ParaSwapSwappedDirect) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(V5ParaSwapSwappedDirect) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *V5ParaSwapSwappedDirectIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *V5ParaSwapSwappedDirectIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// V5ParaSwapSwappedDirect represents a SwappedDirect event raised by the V5ParaSwap contract. +type V5ParaSwapSwappedDirect struct { + Uuid [16]byte + Partner common.Address + FeePercent *big.Int + Initiator common.Address + Kind uint8 + Beneficiary common.Address + SrcToken common.Address + DestToken common.Address + SrcAmount *big.Int + ReceivedAmount *big.Int + ExpectedAmount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSwappedDirect is a free log retrieval operation binding the contract event 0xd2d73da2b5fd52cd654d8fd1b514ad57355bad741de639e3a1c3a20dd9f17347. +// +// Solidity: event SwappedDirect(bytes16 uuid, address partner, uint256 feePercent, address initiator, uint8 kind, address indexed beneficiary, address indexed srcToken, address indexed destToken, uint256 srcAmount, uint256 receivedAmount, uint256 expectedAmount) +func (_V5ParaSwap *V5ParaSwapFilterer) FilterSwappedDirect(opts *bind.FilterOpts, beneficiary []common.Address, srcToken []common.Address, destToken []common.Address) (*V5ParaSwapSwappedDirectIterator, error) { + + var beneficiaryRule []interface{} + for _, beneficiaryItem := range beneficiary { + beneficiaryRule = append(beneficiaryRule, beneficiaryItem) + } + var srcTokenRule []interface{} + for _, srcTokenItem := range srcToken { + srcTokenRule = append(srcTokenRule, srcTokenItem) + } + var destTokenRule []interface{} + for _, destTokenItem := range destToken { + destTokenRule = append(destTokenRule, destTokenItem) + } + + logs, sub, err := _V5ParaSwap.contract.FilterLogs(opts, "SwappedDirect", beneficiaryRule, srcTokenRule, destTokenRule) + if err != nil { + return nil, err + } + return &V5ParaSwapSwappedDirectIterator{contract: _V5ParaSwap.contract, event: "SwappedDirect", logs: logs, sub: sub}, nil +} + +// WatchSwappedDirect is a free log subscription operation binding the contract event 0xd2d73da2b5fd52cd654d8fd1b514ad57355bad741de639e3a1c3a20dd9f17347. +// +// Solidity: event SwappedDirect(bytes16 uuid, address partner, uint256 feePercent, address initiator, uint8 kind, address indexed beneficiary, address indexed srcToken, address indexed destToken, uint256 srcAmount, uint256 receivedAmount, uint256 expectedAmount) +func (_V5ParaSwap *V5ParaSwapFilterer) WatchSwappedDirect(opts *bind.WatchOpts, sink chan<- *V5ParaSwapSwappedDirect, beneficiary []common.Address, srcToken []common.Address, destToken []common.Address) (event.Subscription, error) { + + var beneficiaryRule []interface{} + for _, beneficiaryItem := range beneficiary { + beneficiaryRule = append(beneficiaryRule, beneficiaryItem) + } + var srcTokenRule []interface{} + for _, srcTokenItem := range srcToken { + srcTokenRule = append(srcTokenRule, srcTokenItem) + } + var destTokenRule []interface{} + for _, destTokenItem := range destToken { + destTokenRule = append(destTokenRule, destTokenItem) + } + + logs, sub, err := _V5ParaSwap.contract.WatchLogs(opts, "SwappedDirect", beneficiaryRule, srcTokenRule, destTokenRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(V5ParaSwapSwappedDirect) + if err := _V5ParaSwap.contract.UnpackLog(event, "SwappedDirect", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSwappedDirect is a log parse operation binding the contract event 0xd2d73da2b5fd52cd654d8fd1b514ad57355bad741de639e3a1c3a20dd9f17347. +// +// Solidity: event SwappedDirect(bytes16 uuid, address partner, uint256 feePercent, address initiator, uint8 kind, address indexed beneficiary, address indexed srcToken, address indexed destToken, uint256 srcAmount, uint256 receivedAmount, uint256 expectedAmount) +func (_V5ParaSwap *V5ParaSwapFilterer) ParseSwappedDirect(log types.Log) (*V5ParaSwapSwappedDirect, error) { + event := new(V5ParaSwapSwappedDirect) + if err := _V5ParaSwap.contract.UnpackLog(event, "SwappedDirect", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// V5ParaSwapSwappedV3Iterator is returned from FilterSwappedV3 and is used to iterate over the raw logs and unpacked data for SwappedV3 events raised by the V5ParaSwap contract. +type V5ParaSwapSwappedV3Iterator struct { + Event *V5ParaSwapSwappedV3 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *V5ParaSwapSwappedV3Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(V5ParaSwapSwappedV3) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(V5ParaSwapSwappedV3) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *V5ParaSwapSwappedV3Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *V5ParaSwapSwappedV3Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// V5ParaSwapSwappedV3 represents a SwappedV3 event raised by the V5ParaSwap contract. +type V5ParaSwapSwappedV3 struct { + Uuid [16]byte + Partner common.Address + FeePercent *big.Int + Initiator common.Address + Beneficiary common.Address + SrcToken common.Address + DestToken common.Address + SrcAmount *big.Int + ReceivedAmount *big.Int + ExpectedAmount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSwappedV3 is a free log retrieval operation binding the contract event 0xe00361d207b252a464323eb23d45d42583e391f2031acdd2e9fa36efddd43cb0. +// +// Solidity: event SwappedV3(bytes16 uuid, address partner, uint256 feePercent, address initiator, address indexed beneficiary, address indexed srcToken, address indexed destToken, uint256 srcAmount, uint256 receivedAmount, uint256 expectedAmount) +func (_V5ParaSwap *V5ParaSwapFilterer) FilterSwappedV3(opts *bind.FilterOpts, beneficiary []common.Address, srcToken []common.Address, destToken []common.Address) (*V5ParaSwapSwappedV3Iterator, error) { + + var beneficiaryRule []interface{} + for _, beneficiaryItem := range beneficiary { + beneficiaryRule = append(beneficiaryRule, beneficiaryItem) + } + var srcTokenRule []interface{} + for _, srcTokenItem := range srcToken { + srcTokenRule = append(srcTokenRule, srcTokenItem) + } + var destTokenRule []interface{} + for _, destTokenItem := range destToken { + destTokenRule = append(destTokenRule, destTokenItem) + } + + logs, sub, err := _V5ParaSwap.contract.FilterLogs(opts, "SwappedV3", beneficiaryRule, srcTokenRule, destTokenRule) + if err != nil { + return nil, err + } + return &V5ParaSwapSwappedV3Iterator{contract: _V5ParaSwap.contract, event: "SwappedV3", logs: logs, sub: sub}, nil +} + +// WatchSwappedV3 is a free log subscription operation binding the contract event 0xe00361d207b252a464323eb23d45d42583e391f2031acdd2e9fa36efddd43cb0. +// +// Solidity: event SwappedV3(bytes16 uuid, address partner, uint256 feePercent, address initiator, address indexed beneficiary, address indexed srcToken, address indexed destToken, uint256 srcAmount, uint256 receivedAmount, uint256 expectedAmount) +func (_V5ParaSwap *V5ParaSwapFilterer) WatchSwappedV3(opts *bind.WatchOpts, sink chan<- *V5ParaSwapSwappedV3, beneficiary []common.Address, srcToken []common.Address, destToken []common.Address) (event.Subscription, error) { + + var beneficiaryRule []interface{} + for _, beneficiaryItem := range beneficiary { + beneficiaryRule = append(beneficiaryRule, beneficiaryItem) + } + var srcTokenRule []interface{} + for _, srcTokenItem := range srcToken { + srcTokenRule = append(srcTokenRule, srcTokenItem) + } + var destTokenRule []interface{} + for _, destTokenItem := range destToken { + destTokenRule = append(destTokenRule, destTokenItem) + } + + logs, sub, err := _V5ParaSwap.contract.WatchLogs(opts, "SwappedV3", beneficiaryRule, srcTokenRule, destTokenRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(V5ParaSwapSwappedV3) + if err := _V5ParaSwap.contract.UnpackLog(event, "SwappedV3", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSwappedV3 is a log parse operation binding the contract event 0xe00361d207b252a464323eb23d45d42583e391f2031acdd2e9fa36efddd43cb0. +// +// Solidity: event SwappedV3(bytes16 uuid, address partner, uint256 feePercent, address initiator, address indexed beneficiary, address indexed srcToken, address indexed destToken, uint256 srcAmount, uint256 receivedAmount, uint256 expectedAmount) +func (_V5ParaSwap *V5ParaSwapFilterer) ParseSwappedV3(log types.Log) (*V5ParaSwapSwappedV3, error) { + event := new(V5ParaSwapSwappedV3) + if err := _V5ParaSwap.contract.UnpackLog(event, "SwappedV3", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} From 71c2817891ab69a747157e0cc43a23a1c7099201 Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 16:55:22 +0800 Subject: [PATCH 02/19] feat(worker/polymarket): add new polymarket worker --- go.mod | 2 +- go.sum | 723 ------------------ .../contract/nouns/worker_test.go | 2 +- .../contract/polymarket/worker.go | 221 ++++++ .../contract/polymarket/worker_test.go | 191 +++++ .../engine/worker/decentralized/factory.go | 3 + .../contract/polymarket/abi/CTFExchange.abi | 1 + .../polymarket/abi/ConditionTokens.abi | 1 + .../polymarket/abi/NegRiskCTFExchange.abi | 1 + .../ethereum/contract/polymarket/contract.go | 25 + schema/worker/decentralized/platform.go | 2 + .../worker/decentralized/platform_string.go | 52 +- schema/worker/decentralized/worker.go | 2 + schema/worker/decentralized/worker_string.go | 52 +- 14 files changed, 505 insertions(+), 773 deletions(-) delete mode 100644 go.sum create mode 100644 internal/engine/worker/decentralized/contract/polymarket/worker.go create mode 100644 internal/engine/worker/decentralized/contract/polymarket/worker_test.go create mode 100644 provider/ethereum/contract/polymarket/abi/CTFExchange.abi create mode 100644 provider/ethereum/contract/polymarket/abi/ConditionTokens.abi create mode 100644 provider/ethereum/contract/polymarket/abi/NegRiskCTFExchange.abi create mode 100644 provider/ethereum/contract/polymarket/contract.go diff --git a/go.mod b/go.mod index d60d9b7c..19f6a3e3 100644 --- a/go.mod +++ b/go.mod @@ -62,7 +62,7 @@ require ( github.com/mitchellh/mapstructure v1.5.0 github.com/redis/rueidis v1.0.45 github.com/redis/rueidis/rueidiscompat v1.0.45 - github.com/rss3-network/protocol-go v0.5.6 + github.com/rss3-network/protocol-go v0.5.7 github.com/spf13/afero v1.11.0 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 github.com/tidwall/sjson v1.2.5 diff --git a/go.sum b/go.sum deleted file mode 100644 index b113ccd7..00000000 --- a/go.sum +++ /dev/null @@ -1,723 +0,0 @@ -dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= -dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= -filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= -filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= -github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0= -github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= -github.com/DataDog/zstd v1.5.0 h1:+K/VEwIAaPcHiMtQvpLD4lqW7f0Gk3xdYZmI1hD+CXo= -github.com/DataDog/zstd v1.5.0/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= -github.com/JohannesKaufmann/html-to-markdown v1.6.0 h1:04VXMiE50YYfCfLboJCLcgqF5x+rHJnb1ssNmqpLH/k= -github.com/JohannesKaufmann/html-to-markdown v1.6.0/go.mod h1:NUI78lGg/a7vpEJTz/0uOcYMaibytE4BUOQS8k78yPQ= -github.com/Khan/genqlient v0.7.0 h1:GZ1meyRnzcDTK48EjqB8t3bcfYvHArCUUvgOwpz1D4w= -github.com/Khan/genqlient v0.7.0/go.mod h1:HNyy3wZvuYwmW3Y7mkoQLZsa/R5n5yIRajS1kPBvSFM= -github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= -github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw= -github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= -github.com/PuerkitoBio/goquery v1.9.2 h1:4/wZksC3KgkQw7SQgkKotmKljk0M6V8TUvA8Wb4yPeE= -github.com/PuerkitoBio/goquery v1.9.2/go.mod h1:GHPCaP0ODyyxqcNoFGYlAprUFH81NuRPd0GX3Zu2Mvk= -github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= -github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= -github.com/adrianbrad/psqldocker v1.2.1 h1:bvsRmbotpA89ruqGGzzaAZUBtDaIk98gO+JMBNVSZlI= -github.com/adrianbrad/psqldocker v1.2.1/go.mod h1:LbCnIy60YO6IRJYrF1r+eafKUgU9UnkSFx0gT8UiaUs= -github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ= -github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= -github.com/andybalholm/cascadia v1.2.0/go.mod h1:YCyR8vOZT9aZ1CHEd8ap0gMVm2aFgxBp0T0eFw1RUQY= -github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= -github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= -github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA= -github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE= -github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= -github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= -github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= -github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= -github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U= -github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2 h1:KdUfX2zKommPRa+PD0sWZUyXe9w277ABlgELO7H04IM= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= -github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= -github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= -github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= -github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= -github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= -github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cockroachdb/errors v1.8.1 h1:A5+txlVZfOqFBDa4mGz2bUWSp0aHElvHX2bKkdbQu+Y= -github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac= -github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f h1:o/kfcElHqOiXqcou5a3rIlMc7oJbMQkeLk0VQJ7zgqY= -github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= -github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= -github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= -github.com/cockroachdb/redact v1.0.8 h1:8QG/764wK+vmEYoOlfobpe12EQcS81ukx/a4hdVMxNw= -github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= -github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 h1:IKgmqgMQlVJIZj19CdocBeSfSaiCbEBZGKODaixqtHM= -github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ= -github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= -github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= -github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= -github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= -github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= -github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= -github.com/containerd/continuity v0.4.3 h1:6HVkalIp+2u1ZLH1J/pYX2oBVXlJZvh1X1A7bEZ9Su8= -github.com/containerd/continuity v0.4.3/go.mod h1:F6PTNCKepoxEaXLQp3wDAjygEnImnZ/7o4JzpodfroQ= -github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= -github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= -github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4= -github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= -github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= -github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= -github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= -github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY= -github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= -github.com/creasty/defaults v1.8.0 h1:z27FJxCAa0JKt3utc0sCImAEb+spPucmKoOdLHvHYKk= -github.com/creasty/defaults v1.8.0/go.mod h1:iGzKe6pbEHnpMPtfDXZEr0NVxWnPTjb1bbDy08fPzYM= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/deckarep/golang-set/v2 v2.3.1 h1:vjmkvJt/IV27WXPyYQpAh4bRyWJc5Y435D17XQ9QU5A= -github.com/deckarep/golang-set/v2 v2.3.1/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= -github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y= -github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= -github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= -github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= -github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= -github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= -github.com/docker/cli v26.1.1+incompatible h1:bE1/uE2tCa08fMv+7ikLR/RDPoCqytwrLtkIkSzxLvw= -github.com/docker/cli v26.1.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= -github.com/docker/docker v26.1.3+incompatible h1:lLCzRbrVZrljpVNobJu1J2FHk8V0s4BawoZippkc+xo= -github.com/docker/docker v26.1.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= -github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c= -github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc= -github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= -github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= -github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= -github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= -github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= -github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= -github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= -github.com/ethereum/go-ethereum v1.13.15 h1:U7sSGYGo4SPjP6iNIifNoyIAiNjrmQkz6EwQG+/EZWo= -github.com/ethereum/go-ethereum v1.13.15/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= -github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= -github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA= -github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= -github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= -github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= -github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= -github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= -github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= -github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= -github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4= -github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= -github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= -github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= -github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= -github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= -github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= -github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= -github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= -github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= -github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= -github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= -github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= -github.com/go-playground/form/v4 v4.2.1 h1:HjdRDKO0fftVMU5epjPW2SOREcZ6/wLUzEobqUGJuPw= -github.com/go-playground/form/v4 v4.2.1/go.mod h1:q1a2BY+AQUUzhl6xA/6hBetay6dEIhMHjgvJiGo6K7U= -github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= -github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= -github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= -github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= -github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA= -github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM= -github.com/go-redis/redis v6.15.9+incompatible h1:K0pv1D7EQUjfyoMql+r/jZqCLizCGKFlFgcHWWmHQjg= -github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA= -github.com/go-redis/redis/v7 v7.4.1 h1:PASvf36gyUpr2zdOUS/9Zqc80GbM+9BDyiJSJDDOrTI= -github.com/go-redis/redis/v7 v7.4.1/go.mod h1:JDNMw23GTyLNC4GZu9njt15ctBQVn7xjRfnwdHj/Dcg= -github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI= -github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo= -github.com/go-redsync/redsync/v4 v4.13.0 h1:49X6GJfnbLGaIpBBREM/zA4uIMDXKAh1NDkvQ1EkZKA= -github.com/go-redsync/redsync/v4 v4.13.0/go.mod h1:HMW4Q224GZQz6x1Xc7040Yfgacukdzu7ifTDAKiyErQ= -github.com/go-shiori/dom v0.0.0-20210627111528-4e4722cd0d65 h1:zx4B0AiwqKDQq+AgqxWeHwbbLJQeidq20hgfP+aMNWI= -github.com/go-shiori/dom v0.0.0-20210627111528-4e4722cd0d65/go.mod h1:NPO1+buE6TYOWhUI98/hXLHHJhunIpXRuvDN4xjkCoE= -github.com/go-shiori/go-readability v0.0.0-20231029095239-6b97d5aba789 h1:G6wSuUyCoLB9jrUokipsmFuRi8aJozt3phw/g9Sl4Xs= -github.com/go-shiori/go-readability v0.0.0-20231029095239-6b97d5aba789/go.mod h1:2DpZlTJO/ycxp/vsc/C11oUyveStOgIXB88SYV1lncI= -github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y= -github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= -github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= -github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= -github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= -github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= -github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= -github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= -github.com/gogs/chardet v0.0.0-20191104214054-4b6791f73a28/go.mod h1:Pcatq5tYkCW2Q6yrR2VRHlbHpZ/R4/7qyL1TCF7vl14= -github.com/gogs/chardet v0.0.0-20211120154057-b7413eaefb8f h1:3BSP1Tbs2djlpprl7wCLuiqMaUh5SJkkzI2gDs+FgLs= -github.com/gogs/chardet v0.0.0-20211120154057-b7413eaefb8f/go.mod h1:Pcatq5tYkCW2Q6yrR2VRHlbHpZ/R4/7qyL1TCF7vl14= -github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= -github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= -github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= -github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= -github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= -github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= -github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= -github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= -github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= -github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= -github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= -github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/gomodule/redigo v1.8.9 h1:Sl3u+2BI/kk+VEatbj0scLdrFhjPmbxOc1myhDP41ws= -github.com/gomodule/redigo v1.8.9/go.mod h1:7ArFNvsTjH8GMMzB4uy1snslv2BwmginuMs06a1uzZE= -github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= -github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8 h1:FKHo8hFI3A+7w0aUQuYXQ+6EN5stWmeY/AZqtM8xk9k= -github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo= -github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= -github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= -github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= -github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= -github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= -github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/grafana/pyroscope-go v1.1.2 h1:7vCfdORYQMCxIzI3NlYAs3FcBP760+gWuYWOyiVyYx8= -github.com/grafana/pyroscope-go v1.1.2/go.mod h1:HSSmHo2KRn6FasBA4vK7BMiQqyQq8KSuBKvrhkXxYPU= -github.com/grafana/pyroscope-go/godeltaprof v0.1.8 h1:iwOtYXeeVSAeYefJNaxDytgjKtUuKQbJqgAIjlnicKg= -github.com/grafana/pyroscope-go/godeltaprof v0.1.8/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I= -github.com/hamba/avro v1.8.0 h1:eCVrLX7UYThA3R3yBZ+rpmafA5qTc3ZjpTz6gYJoVGU= -github.com/hamba/avro v1.8.0/go.mod h1:NiGUcrLLT+CKfGu5REWQtD9OVPPYUGMVFiC+DE0lQfY= -github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= -github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= -github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= -github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= -github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= -github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= -github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= -github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= -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/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4= -github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= -github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= -github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= -github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= -github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= -github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= -github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= -github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= -github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= -github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= -github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= -github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= -github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= -github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= -github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 h1:L0QtFUgDarD7Fpv9jeVMgy/+Ec0mtnmYuImjTz6dtDA= -github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= -github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY= -github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw= -github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= -github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= -github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= -github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= -github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= -github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= -github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= -github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= -github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= -github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= -github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= -github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= -github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg= -github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= -github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/labstack/echo/v4 v4.12.0 h1:IKpw49IMryVB2p1a4dzwlhP1O2Tf2E0Ir/450lH+kI0= -github.com/labstack/echo/v4 v4.12.0/go.mod h1:UP9Cr2DJXbOK3Kr9ONYzNowSh7HP0aG0ShAyycHSJvM= -github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0= -github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU= -github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= -github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= -github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= -github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= -github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= -github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= -github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= -github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= -github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ= -github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= -github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= -github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= -github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= -github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY= -github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg= -github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= -github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= -github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= -github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= -github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= -github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= -github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= -github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= -github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= -github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= -github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0= -github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y= -github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= -github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= -github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= -github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= -github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= -github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE= -github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI= -github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0= -github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4= -github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g= -github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk= -github.com/multiformats/go-multicodec v0.9.0 h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg= -github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k= -github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U= -github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM= -github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8= -github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU= -github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= -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/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= -github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= -github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= -github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= -github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= -github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= -github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= -github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= -github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= -github.com/onsi/ginkgo/v2 v2.20.1 h1:YlVIbqct+ZmnEph770q9Q7NVAz4wwIiVNahee6JyUzo= -github.com/onsi/ginkgo/v2 v2.20.1/go.mod h1:lG9ey2Z29hR41WMVthyJBGUBcBhGOtoPF2VFMvBXFCI= -github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= -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.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k= -github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY= -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.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug= -github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= -github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss= -github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8= -github.com/orlangure/gnomock v0.31.0 h1:dgjlQ8DYUPMyNwMZJuYBH+/GF+e7h3sloldPzIJF4k4= -github.com/orlangure/gnomock v0.31.0/go.mod h1:RagxeYv3bKi+li9Lio2Faw5t6Mcy4akkeqXzkgAS3w0= -github.com/ory/dockertest/v3 v3.10.0 h1:4K3z2VMe8Woe++invjaTB7VRyQXQy5UY+loujO4aNE4= -github.com/ory/dockertest/v3 v3.10.0/go.mod h1:nr57ZbRWMqfsdGdFNLHz5jjNdDb7VVFnzAeW1n5N1Lg= -github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= -github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= -github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ= -github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= -github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pressly/goose/v3 v3.22.0 h1:wd/7kNiPTuNAztWun7iaB98DrhulbWPrzMAaw2DEZNw= -github.com/pressly/goose/v3 v3.22.0/go.mod h1:yJM3qwSj2pp7aAaCvso096sguezamNb2OBgxCnh/EYg= -github.com/prometheus/client_golang v1.20.3 h1:oPksm4K8B+Vt35tUhw6GbSNSgVlVSBH0qELP/7u83l4= -github.com/prometheus/client_golang v1.20.3/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= -github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= -github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= -github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc= -github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8= -github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= -github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= -github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8= -github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= -github.com/redis/rueidis v1.0.45 h1:j7hfcqfLLIqgTK3IkxBhXdeJcP34t3XLXvorDLqXfgM= -github.com/redis/rueidis v1.0.45/go.mod h1:by+34b0cFXndxtYmPAHpoTHO5NkosDlBvhexoTURIxM= -github.com/redis/rueidis/mock v1.0.45 h1:r2LRiwOtFib8+NAuVxNmcdxL7IMUk3as9IGPzx2v5tA= -github.com/redis/rueidis/mock v1.0.45/go.mod h1:bjpk7ox5jwue03L8NpjgPBE91tLkm9Amla+XFYhaezc= -github.com/redis/rueidis/rueidiscompat v1.0.45 h1:G+3HIaETgtwr6aL6BOTFCa2DfpPDhxqcoiDn8cvd5Ps= -github.com/redis/rueidis/rueidiscompat v1.0.45/go.mod h1:JMw3cktmwNqsSl2npjcxrOfLa1L3rmj1Ox5aPHiDjOU= -github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= -github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= -github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= -github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs= -github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro= -github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= -github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= -github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= -github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= -github.com/rss3-network/protocol-go v0.5.6 h1:YBANVsOP9sW5i/1ghFc3zSqlNyTl1ug8FTZeNDRaklI= -github.com/rss3-network/protocol-go v0.5.6/go.mod h1:npcyduWt86uVbIi77xQaYk8eqltI9XNjk1FMGpjyIq0= -github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww= -github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= -github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= -github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= -github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= -github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= -github.com/samber/lo v1.47.0 h1:z7RynLwP5nbyRscyvcD043DWYoOcYRv3mV8lBeqOCLc= -github.com/samber/lo v1.47.0/go.mod h1:RmDH9Ct32Qy3gduHQuKJ3gW1fMHAnE/fAzQuf6He5cU= -github.com/sebdah/goldie/v2 v2.5.3 h1:9ES/mNN+HNUbNWpVAlrzuZ7jE+Nrczbj8uFRjM7624Y= -github.com/sebdah/goldie/v2 v2.5.3/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI= -github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= -github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8= -github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I= -github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE= -github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas= -github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= -github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= -github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= -github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= -github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= -github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= -github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= -github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= -github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= -github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= -github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= -github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0= -github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= -github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM= -github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y= -github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= -github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI= -github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg= -github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= -github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203 h1:QVqDTf3h2WHt08YuiTGPZLls0Wq99X9bWd0Q5ZSBesM= -github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203/go.mod h1:oqN97ltKNihBbwlX8dLpwxCl3+HnXKV/R0e+sRLd9C8= -github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= -github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= -github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= -github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= -github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= -github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= -github.com/tdewolff/minify/v2 v2.20.37 h1:Q97cx4STXCh1dlWDlNHZniE8BJ2EBL0+2b0n92BJQhw= -github.com/tdewolff/minify/v2 v2.20.37/go.mod h1:L1VYef/jwKw6Wwyk5A+T0mBjjn3mMPgmjjA688RNsxU= -github.com/tdewolff/parse/v2 v2.7.15 h1:hysDXtdGZIRF5UZXwpfn3ZWRbm+ru4l53/ajBRGpCTw= -github.com/tdewolff/parse/v2 v2.7.15/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA= -github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE= -github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739 h1:IkjBCtQOOjIn03u/dMQK9g+Iw9ewps4mCl1nB8Sscbo= -github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8= -github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= -github.com/tidwall/gjson v1.17.3 h1:bwWLZU7icoKRG+C+0PNwIKC6FCJO/Q3p2pZvuP0jN94= -github.com/tidwall/gjson v1.17.3/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= -github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= -github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= -github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= -github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= -github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= -github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= -github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= -github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= -github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= -github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= -github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= -github.com/twmb/franz-go v1.17.1 h1:0LwPsbbJeJ9R91DPUHSEd4su82WJWcTY1Zzbgbg4CeQ= -github.com/twmb/franz-go v1.17.1/go.mod h1:NreRdJ2F7dziDY/m6VyspWd6sNxHKXdMZI42UfQ3GXM= -github.com/twmb/franz-go/pkg/kadm v1.13.0 h1:bJq4C2ZikUE2jh/wl9MtMTQ/kpmnBgVFh8XMQBEC+60= -github.com/twmb/franz-go/pkg/kadm v1.13.0/go.mod h1:VMvpfjz/szpH9WB+vGM+rteTzVv0djyHFimci9qm2C0= -github.com/twmb/franz-go/pkg/kmsg v1.8.0 h1:lAQB9Z3aMrIP9qF9288XcFf/ccaSxEitNA1CDTEIeTA= -github.com/twmb/franz-go/pkg/kmsg v1.8.0/go.mod h1:HzYEb8G3uu5XevZbtU0dVbkphaKTHk0X68N5ka4q6mU= -github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= -github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= -github.com/urfave/cli v1.22.1 h1:+mkCCcOFKPnCmVYVcURKps1Xe+3zP90gSYGNfRkjoIY= -github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs= -github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= -github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo= -github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= -github.com/vektah/gqlparser/v2 v2.5.11 h1:JJxLtXIoN7+3x6MBdtIP59TP1RANnY7pXOaDnADQSf8= -github.com/vektah/gqlparser/v2 v2.5.11/go.mod h1:1rCcfwB2ekJofmluGWXMSEnPMZgbxzwj6FaZ/4OT8Cc= -github.com/vincent-petithory/dataurl v1.0.0 h1:cXw+kPto8NLuJtlMsI152irrVw9fRDX8AbShPRpg2CI= -github.com/vincent-petithory/dataurl v1.0.0/go.mod h1:FHafX5vmDzyP+1CQATJn7WFKc9CvnvxyvZy6I1MrG/U= -github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= -github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo= -github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= -github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0= -github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= -github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= -github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= -github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -github.com/yuin/goldmark v1.7.1 h1:3bajkSilaCbjdKVsKdZjZCLBNPL9pYzrCakKaf4U49U= -github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E= -github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw= -github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.50.0 h1:cEPbyTSEHlQR89XVlyo78gqluF8Y3oMeBkXGWzQsfXY= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.50.0/go.mod h1:DKdbWcT4GH1D0Y3Sqt/PFXt2naRKDWtU+eE6oLdFNA8= -go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw= -go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0 h1:dIIDULZJpgdiHz5tXrTgKIMLkus6jEFa7x5SOKcyR7E= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0/go.mod h1:jlRVBe7+Z1wyxFSUs48L6OBQZ5JwH2Hg/Vbl+t9rAgI= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.29.0 h1:JAv0Jwtl01UFiyWZEMiJZBiTlv5A50zNs8lsthXqIio= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.29.0/go.mod h1:QNKLmUEAq2QUbPQUfvw4fmv0bgbK7UlOSFCnXyfvSNc= -go.opentelemetry.io/otel/exporters/prometheus v0.51.0 h1:G7uexXb/K3T+T9fNLCCKncweEtNEBMTO+46hKX5EdKw= -go.opentelemetry.io/otel/exporters/prometheus v0.51.0/go.mod h1:v0mFe5Kk7woIh938mrZBJBmENYquyA0IICrlYm4Y0t4= -go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.29.0 h1:X3ZjNp36/WlkSYx0ul2jw4PtbNEDDeLskw3VPsrpYM0= -go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.29.0/go.mod h1:2uL/xnOXh0CHOBFCWXz5u1A4GXLiW+0IQIzVbeOEQ0U= -go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc= -go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8= -go.opentelemetry.io/otel/sdk v1.29.0 h1:vkqKjk7gwhS8VaWb0POZKmIEDimRCMsopNYnriHyryo= -go.opentelemetry.io/otel/sdk v1.29.0/go.mod h1:pM8Dx5WKnvxLCb+8lG1PRNIDxu9g9b9g59Qr7hfAAok= -go.opentelemetry.io/otel/sdk/metric v1.29.0 h1:K2CfmJohnRgvZ9UAj2/FhIf/okdWcNdBwe1m8xFXiSY= -go.opentelemetry.io/otel/sdk/metric v1.29.0/go.mod h1:6zZLdCl2fkauYoZIOn/soQIDSWFmNSRcICarHfuhNJQ= -go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4= -go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ= -go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0= -go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8= -go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= -go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= -go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= -go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= -go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= -go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= -go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= -go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= -go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= -go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= -go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= -golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M= -golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= -golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= -golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= -golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= -golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= -golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.0.0-20210505214959-0714010a04ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= -golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= -golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= -golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8= -golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= -golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo= -golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0= -golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= -golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= -golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= -golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= -golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= -golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= -golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk= -golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224= -golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= -golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= -golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= -golang.org/x/tools v0.24.0 h1:J1shsA93PJUEVaUSaay7UXAyE8aimq3GW0pjlolpa24= -golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd h1:BBOTEWLuuEGQy9n1y9MhVJ9Qt0BDu21X8qZs71/uPZo= -google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd/go.mod h1:fO8wJzT2zbQbAjbIoos1285VfEIYKDDY+Dt+WpTkh6g= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd h1:6TEm2ZxXoQmFWFlt1vNxvVOa1Q0dXFQD1m/rYjXmS0E= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= -google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc= -google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ= -google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= -google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= -google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= -google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= -google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= -google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= -google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= -gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= -gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8= -gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= -gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= -gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= -gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gorm.io/driver/postgres v1.5.9 h1:DkegyItji119OlcaLjqN11kHoUgZ/j13E0jkJZgD6A8= -gorm.io/driver/postgres v1.5.9/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI= -gorm.io/gorm v1.23.6/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk= -gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg= -gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= -gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo= -gotest.tools/v3 v3.3.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= -lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI= -lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k= -modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI= -modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4= -modernc.org/libc v1.55.3 h1:AzcW1mhlPNrRtjS5sS+eW2ISCgSOLLNyFzRh/V3Qj/U= -modernc.org/libc v1.55.3/go.mod h1:qFXepLhz+JjFThQ4kzwzOjA/y/artDeg+pcYnY+Q83w= -modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= -modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= -modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E= -modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU= -modernc.org/sqlite v1.32.0 h1:6BM4uGza7bWypsw4fdLRsLxut6bHe4c58VeqjRgST8s= -modernc.org/sqlite v1.32.0/go.mod h1:UqoylwmTb9F+IqXERT8bW9zzOWN8qwAIcLdzeBZs4hA= -modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA= -modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0= -modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= -modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= -moul.io/zapgorm2 v1.3.0 h1:+CzUTMIcnafd0d/BvBce8T4uPn6DQnpIrz64cyixlkk= -moul.io/zapgorm2 v1.3.0/go.mod h1:nPVy6U9goFKHR4s+zfSo1xVFaoU7Qgd5DoCdOfzoCqs= -rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= -rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/internal/engine/worker/decentralized/contract/nouns/worker_test.go b/internal/engine/worker/decentralized/contract/nouns/worker_test.go index 4374392f..c24b4d0f 100644 --- a/internal/engine/worker/decentralized/contract/nouns/worker_test.go +++ b/internal/engine/worker/decentralized/contract/nouns/worker_test.go @@ -733,7 +733,7 @@ func TestWorker_Ethereum(t *testing.T) { From: "0x0a049e014999A489b3D7174B8f70D4200b0Ce79B", To: "0x6f3E6272A167e8AcCb32072d08E0957F9c79223d", Metadata: metadata.GovernanceVote{ - Action: metadata.ActionGovernanceFor, + Action: metadata.ActionGovernanceVoteFor, Count: 2, Reason: "For: 3 | Against: 1 | Abstain: 0\n\n+for — @87bones\n\n+for — @roxby\n\n+for Also hoping to see some cool ⌐◨-◨ inspired furniture/infra in the gallery — @wideeyekarl\n\n+against — @bixbite", Proposal: metadata.GovernanceProposal{ diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker.go b/internal/engine/worker/decentralized/contract/polymarket/worker.go new file mode 100644 index 00000000..558a3ed4 --- /dev/null +++ b/internal/engine/worker/decentralized/contract/polymarket/worker.go @@ -0,0 +1,221 @@ +package polymarket + +import ( + "context" + "fmt" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/rss3-network/node/config" + "github.com/rss3-network/node/internal/engine" + source "github.com/rss3-network/node/internal/engine/source/ethereum" + "github.com/rss3-network/node/provider/ethereum" + "github.com/rss3-network/node/provider/ethereum/contract" + "github.com/rss3-network/node/provider/ethereum/contract/polymarket" + "github.com/rss3-network/node/provider/ethereum/token" + "github.com/rss3-network/node/schema/worker/decentralized" + "github.com/rss3-network/protocol-go/schema" + activityx "github.com/rss3-network/protocol-go/schema/activity" + "github.com/rss3-network/protocol-go/schema/metadata" + "github.com/rss3-network/protocol-go/schema/network" + "github.com/rss3-network/protocol-go/schema/tag" + "github.com/rss3-network/protocol-go/schema/typex" + "github.com/samber/lo" + "github.com/shopspring/decimal" + "go.uber.org/zap" +) + +var _ engine.Worker = (*worker)(nil) + +type worker struct { + ethereumClient ethereum.Client + tokenClient token.Client + ctfExchange *polymarket.CTFExchangeFilterer + negRiskCTF *polymarket.NegRiskCTFExchangeFilterer +} + +func (w *worker) Name() string { + return decentralized.Polymarket.String() +} + +func (w *worker) Platform() string { + return decentralized.PlatformPolymarket.String() +} + +func (w *worker) Network() []network.Network { + return []network.Network{ + network.Polygon, + } +} + +func (w *worker) Tags() []tag.Tag { + return []tag.Tag{ + tag.Collectible, + } +} + +func (w *worker) Types() []schema.Type { + return []schema.Type{ + typex.CollectibleTrade, + } +} + +func (w *worker) Filter() engine.DataSourceFilter { + return &source.Filter{ + LogAddresses: []common.Address{ + polymarket.AddressPolyMarketCTFExchange, + polymarket.AddressPolyMarketNegRiskCTFExchange, + }, + LogTopics: []common.Hash{ + polymarket.EventOrderFinalized, + }, + } +} + +func (w *worker) Transform(ctx context.Context, task engine.Task) (*activityx.Activity, error) { + polygonTask, ok := task.(*source.Task) + if !ok { + return nil, fmt.Errorf("invalid task type %T", task) + } + + activity, err := task.BuildActivity(activityx.WithActivityPlatform(w.Platform())) + if err != nil { + return nil, fmt.Errorf("build activity: %w", err) + } + + activity.Type = typex.CollectibleTrade + activity.Actions = w.transformOrderTransaction(ctx, polygonTask) + + return activity, nil +} + +func (w *worker) transformOrderTransaction(ctx context.Context, polygonTask *source.Task) (actions []*activityx.Action) { + for _, log := range polygonTask.Receipt.Logs { + if len(log.Topics) == 0 { + continue + } + + var ( + buffer []*activityx.Action + err error + ) + + if !w.matchOrderFinalizedLog(polygonTask, log) { + continue + } + + buffer, err = w.transformOrderFinalizedLog(ctx, polygonTask, log) + if err != nil { + zap.L().Warn("handle polymarket order transaction", zap.Error(err), zap.String("worker", w.Name()), zap.String("task", polygonTask.ID())) + continue + } + + actions = append(actions, buffer...) + } + + return actions +} + +func (w *worker) matchOrderFinalizedLog(_ *source.Task, log *ethereum.Log) bool { + return contract.MatchEventHashes(log.Topics[0], polymarket.EventOrderFinalized) && + contract.MatchAddresses(log.Address, polymarket.AddressPolyMarketCTFExchange, polymarket.AddressPolyMarketNegRiskCTFExchange) +} + +func (w *worker) transformOrderFinalizedLog(ctx context.Context, task *source.Task, log *ethereum.Log) ([]*activityx.Action, error) { + var err error + + // CTF and NegRiskCTF shares the same OrderFilled struct + event, err := w.ctfExchange.ParseOrderFilled(log.Export()) + + if err != nil { + return nil, fmt.Errorf("parse OrderFilled event: %w", err) + } + + buyAction, sellAction, err := w.buildMarketTradeAction(ctx, task, task.ChainID, event.Maker, event.Taker, event.MakerAssetId, event.TakerAssetId, event.OrderHash, event.MakerAmountFilled, event.TakerAmountFilled) + if err != nil { + return nil, fmt.Errorf("build market trade action: %w", err) + } + + return []*activityx.Action{buyAction, sellAction}, nil +} + +func (w *worker) buildMarketTradeAction(ctx context.Context, _ *source.Task, chainID uint64, maker, taker common.Address, makerAssetID, takerAssetID *big.Int, _ [32]byte, makerAmountFilled, takerAmountFilled *big.Int) (*activityx.Action, *activityx.Action, error) { + makerAmountFilledDecimal := decimal.NewFromBigInt(makerAmountFilled, 0) + takerAmountFilledDecimal := decimal.NewFromBigInt(takerAmountFilled, 0) + + var takerTokenAddress *common.Address + if takerAssetID.Cmp(big.NewInt(0)) == 0 { + takerTokenAddress = nil + } else { + address := common.HexToAddress(polymarket.AddressPolyMarketConditionTokens.String()) + takerTokenAddress = &address + } + + takerToken, err := w.tokenClient.Lookup(ctx, chainID, takerTokenAddress, takerAssetID, nil) + + if err != nil { + return nil, nil, fmt.Errorf("lookup taker token: %w", err) + } + + takerToken.Value = &takerAmountFilledDecimal + + var makerTokenAddress *common.Address + + if makerAssetID.Cmp(big.NewInt(0)) == 0 { + makerTokenAddress = nil + } else { + address := common.HexToAddress(polymarket.AddressPolyMarketConditionTokens.String()) + makerTokenAddress = &address + } + + makerToken, err := w.tokenClient.Lookup(ctx, chainID, makerTokenAddress, makerAssetID, nil) + if err != nil { + return nil, nil, fmt.Errorf("lookup maker token: %w", err) + } + + makerToken.Value = &makerAmountFilledDecimal + + buyAction := &activityx.Action{ + Type: typex.CollectibleTrade, + Platform: w.Platform(), + From: maker.String(), + To: taker.String(), + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeBuy, + Token: *makerToken, + Cost: takerToken, + }, + } + + // Sell action (from the maker's perspective) + sellAction := &activityx.Action{ + Type: typex.CollectibleTrade, + Platform: w.Platform(), + From: maker.String(), + To: taker.String(), + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeSell, + Token: *takerToken, + Cost: makerToken, + }, + } + + return buyAction, sellAction, nil +} + +func NewWorker(config *config.Module) (engine.Worker, error) { + instance := worker{ + ctfExchange: lo.Must(polymarket.NewCTFExchangeFilterer(ethereum.AddressGenesis, nil)), + negRiskCTF: lo.Must(polymarket.NewNegRiskCTFExchangeFilterer(ethereum.AddressGenesis, nil)), + } + + var err error + + if instance.ethereumClient, err = ethereum.Dial(context.Background(), config.Endpoint.URL, config.Endpoint.BuildEthereumOptions()...); err != nil { + return nil, fmt.Errorf("initialize ethereum client: %w", err) + } + + instance.tokenClient = token.NewClient(instance.ethereumClient) + + return &instance, nil +} diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go new file mode 100644 index 00000000..c31ec514 --- /dev/null +++ b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go @@ -0,0 +1,191 @@ +package polymarket_test + +import ( + "context" + "encoding/json" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/rss3-network/node/config" + source "github.com/rss3-network/node/internal/engine/source/ethereum" + worker "github.com/rss3-network/node/internal/engine/worker/decentralized/contract/polymarket" + "github.com/rss3-network/node/provider/ethereum" + "github.com/rss3-network/node/provider/ethereum/endpoint" + workerx "github.com/rss3-network/node/schema/worker/decentralized" + activityx "github.com/rss3-network/protocol-go/schema/activity" + "github.com/rss3-network/protocol-go/schema/metadata" + "github.com/rss3-network/protocol-go/schema/network" + "github.com/rss3-network/protocol-go/schema/typex" + "github.com/samber/lo" + "github.com/shopspring/decimal" + "github.com/stretchr/testify/require" +) + +func TestWorker_Polymarket(t *testing.T) { + t.Parallel() + + type arguments struct { + task *source.Task + config *config.Module + } + + testcases := []struct { + name string + arguments arguments + want *activityx.Activity + wantError require.ErrorAssertionFunc + }{ + { + name: "Test Prediction Offer Finalization (buy, sell actions)", + arguments: struct { + task *source.Task + config *config.Module + }{ + task: &source.Task{ + Network: network.Polygon, + ChainID: 137, + Header: ðereum.Header{ + Hash: common.HexToHash("0x32422585cf4fdb3977cbb80f53e02211bc88b8bed1f4528907937d7b8db2bb9d"), + ParentHash: common.HexToHash("0x2bcbe0471d721245fdf728d54f2c9148ea1997ba0bb7d16a06e918b11c20babb"), + UncleHash: common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"), + Coinbase: common.HexToAddress("0x4F080de0d0CC72e091a77cD03036750Adc47060e"), + Number: lo.Must(new(big.Int).SetString("61724368", 0)), + GasLimit: 30000000, + GasUsed: 11394017, + Timestamp: 1726122849, + BaseFee: lo.Must(new(big.Int).SetString("23", 0)), + Transactions: nil, + }, + Transaction: ðereum.Transaction{ + BlockHash: common.HexToHash("0xee69b38fad2d28c86d6fd838ba0ab328844c753b67ceec37e3433aec58d71c1b"), + From: common.HexToAddress("0x429B8474BD7308b7787d364985bB4b8eA7De1D47"), + Gas: 1200000, + GasPrice: lo.Must(new(big.Int).SetString("105000000023", 10)), + Hash: common.HexToHash("0xee69b38fad2d28c86d6fd838ba0ab328844c753b67ceec37e3433aec58d71c1b"), + Input: hexutil.MustDecode("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"), + To: lo.ToPtr(common.HexToAddress("0x56C79347e95530c01A2FC76E732f9566dA16E113")), + Value: lo.Must(new(big.Int).SetString("0", 0)), + Type: 2, + ChainID: lo.Must(new(big.Int).SetString("137", 0)), + }, + Receipt: ðereum.Receipt{ + BlockHash: common.HexToHash("0x32422585cf4fdb3977cbb80f53e02211bc88b8bed1f4528907937d7b8db2bb9d"), + BlockNumber: lo.Must(new(big.Int).SetString("61724368", 0)), + ContractAddress: nil, + CumulativeGasUsed: 1033301, + EffectiveGasPrice: hexutil.MustDecodeBig("0x18727cda17"), + GasUsed: 478405, + + Logs: []*ethereum.Log{{ + Address: common.HexToAddress("0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E"), + Topics: []common.Hash{ + common.HexToHash("0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6"), + common.HexToHash("0x629828c8f231e1ee97e793768b807a5f940bb30dc5e28fe1e7fa30137e76eac1"), + common.HexToHash("0x000000000000000000000000abf500a9b3481ee143fde5078df1a202eb88a4a6"), + common.HexToHash("0x00000000000000000000000043ed7d1bf7c703136971ae5e64f6e7feea435535"), + }, + Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000000000000000000000012b2de357d4a2d0c4160fcda37eb93483a7d40180de99454026156695463f2b50000000000000000000000000000000000000000000000000000000004bd2be000000000000000000000000000000000000000000000000000000000105759800000000000000000000000000000000000000000000000000000000000000000"), + BlockNumber: lo.Must(new(big.Int).SetString("61724368", 0)), + TransactionHash: common.HexToHash("0xee69b38fad2d28c86d6fd838ba0ab328844c753b67ceec37e3433aec58d71c1b"), + Index: 33, + Removed: false, + }}, + Status: 1, + TransactionHash: common.HexToHash("0xee69b38fad2d28c86d6fd838ba0ab328844c753b67ceec37e3433aec58d71c1b"), + TransactionIndex: 4, + }, + }, + config: &config.Module{ + Network: network.Polygon, + Endpoint: config.Endpoint{ + URL: endpoint.MustGet(network.Polygon), + }, + }, + }, + want: &activityx.Activity{ + ID: "0xee69b38fad2d28c86d6fd838ba0ab328844c753b67ceec37e3433aec58d71c1b", + Network: network.Polygon, + Index: 4, + From: "0x429B8474BD7308b7787d364985bB4b8eA7De1D47", + To: "0x56C79347e95530c01A2FC76E732f9566dA16E113", + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + Fee: &activityx.Fee{ + Amount: lo.Must(decimal.NewFromString("50232525011003315")), + Decimal: 18, + }, + Calldata: &activityx.Calldata{ + FunctionHash: "0xd2539b37", + }, + Actions: []*activityx.Action{ + { + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + From: "0xABf500a9b3481Ee143FDE5078df1A202Eb88A4A6", + To: "0x43eD7d1Bf7c703136971Ae5E64F6E7fEeA435535", + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeBuy, + Token: metadata.Token{ + Name: "Polygon", + Symbol: "MATIC", + Decimals: 18, + Value: lo.ToPtr(lo.Must(decimal.NewFromString("79506400"))), + }, + Cost: &metadata.Token{ + Address: lo.ToPtr("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"), + ID: lo.ToPtr(lo.Must(decimal.NewFromString("8457663681790058947550769538996974245890751367516560139630487435494614626997"))), + Value: lo.ToPtr(lo.Must(decimal.NewFromString("274160000"))), + Standard: metadata.StandardERC1155, + }, + }, + }, + { + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + From: "0xABf500a9b3481Ee143FDE5078df1A202Eb88A4A6", + To: "0x43eD7d1Bf7c703136971Ae5E64F6E7fEeA435535", + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeSell, + Token: metadata.Token{ + Address: lo.ToPtr("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"), + ID: lo.ToPtr(lo.Must(decimal.NewFromString("8457663681790058947550769538996974245890751367516560139630487435494614626997"))), + Value: lo.ToPtr(lo.Must(decimal.NewFromString("274160000"))), + Standard: metadata.StandardERC1155, + }, + Cost: &metadata.Token{ + Name: "Polygon", + Symbol: "MATIC", + Decimals: 18, + Value: lo.ToPtr(lo.Must(decimal.NewFromString("79506400"))), + }, + }, + }}, + Status: true, + Timestamp: 1726122849, + }, + wantError: require.NoError, + }, + } + + for _, testcase := range testcases { + testcase := testcase + + t.Run(testcase.name, func(t *testing.T) { + t.Parallel() + + ctx := context.Background() + + instance, err := worker.NewWorker(testcase.arguments.config) + require.NoError(t, err) + + activity, err := instance.Transform(ctx, testcase.arguments.task) + testcase.wantError(t, err) + + t.Log(string(lo.Must(json.MarshalIndent(activity, "", "\x20\x20")))) + + require.Equal(t, testcase.want, activity) + }) + } +} diff --git a/internal/engine/worker/decentralized/factory.go b/internal/engine/worker/decentralized/factory.go index 3aaa096b..eacb57b3 100644 --- a/internal/engine/worker/decentralized/factory.go +++ b/internal/engine/worker/decentralized/factory.go @@ -32,6 +32,7 @@ import ( "github.com/rss3-network/node/internal/engine/worker/decentralized/contract/optimism" "github.com/rss3-network/node/internal/engine/worker/decentralized/contract/paragraph" "github.com/rss3-network/node/internal/engine/worker/decentralized/contract/paraswap" + "github.com/rss3-network/node/internal/engine/worker/decentralized/contract/polymarket" "github.com/rss3-network/node/internal/engine/worker/decentralized/contract/rss3" "github.com/rss3-network/node/internal/engine/worker/decentralized/contract/savm" "github.com/rss3-network/node/internal/engine/worker/decentralized/contract/stargate" @@ -112,6 +113,8 @@ func newNonCoreWorker(config *config.Module, databaseClient database.Client, red return base.NewWorker(config) case decentralized.Linea: return linea.NewWorker(config) + case decentralized.Polymarket: + return polymarket.NewWorker(config) default: return nil, fmt.Errorf("unsupported worker %s", config.Worker) } diff --git a/provider/ethereum/contract/polymarket/abi/CTFExchange.abi b/provider/ethereum/contract/polymarket/abi/CTFExchange.abi new file mode 100644 index 00000000..63a31286 --- /dev/null +++ b/provider/ethereum/contract/polymarket/abi/CTFExchange.abi @@ -0,0 +1 @@ +[{"inputs":[{"internalType":"address","name":"_collateral","type":"address"},{"internalType":"address","name":"_ctf","type":"address"},{"internalType":"address","name":"_proxyFactory","type":"address"},{"internalType":"address","name":"_safeFactory","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyRegistered","type":"error"},{"inputs":[],"name":"FeeTooHigh","type":"error"},{"inputs":[],"name":"InvalidComplement","type":"error"},{"inputs":[],"name":"InvalidNonce","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[],"name":"InvalidTokenId","type":"error"},{"inputs":[],"name":"MakingGtRemaining","type":"error"},{"inputs":[],"name":"MismatchedTokenIds","type":"error"},{"inputs":[],"name":"NotAdmin","type":"error"},{"inputs":[],"name":"NotCrossing","type":"error"},{"inputs":[],"name":"NotOperator","type":"error"},{"inputs":[],"name":"NotOwner","type":"error"},{"inputs":[],"name":"NotTaker","type":"error"},{"inputs":[],"name":"OrderExpired","type":"error"},{"inputs":[],"name":"OrderFilledOrCancelled","type":"error"},{"inputs":[],"name":"Paused","type":"error"},{"inputs":[],"name":"TooLittleTokensReceived","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeCharged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAdminAddress","type":"address"},{"indexed":true,"internalType":"address","name":"admin","type":"address"}],"name":"NewAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newOperatorAddress","type":"address"},{"indexed":true,"internalType":"address","name":"admin","type":"address"}],"name":"NewOperator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"OrderCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"maker","type":"address"},{"indexed":true,"internalType":"address","name":"taker","type":"address"},{"indexed":false,"internalType":"uint256","name":"makerAssetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerAssetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"makerAmountFilled","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerAmountFilled","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"OrderFilled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"takerOrderHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"takerOrderMaker","type":"address"},{"indexed":false,"internalType":"uint256","name":"makerAssetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerAssetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"makerAmountFilled","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerAmountFilled","type":"uint256"}],"name":"OrdersMatched","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldProxyFactory","type":"address"},{"indexed":true,"internalType":"address","name":"newProxyFactory","type":"address"}],"name":"ProxyFactoryUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"removedAdmin","type":"address"},{"indexed":true,"internalType":"address","name":"admin","type":"address"}],"name":"RemovedAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"removedOperator","type":"address"},{"indexed":true,"internalType":"address","name":"admin","type":"address"}],"name":"RemovedOperator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldSafeFactory","type":"address"},{"indexed":true,"internalType":"address","name":"newSafeFactory","type":"address"}],"name":"SafeFactoryUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"token0","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"token1","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"conditionId","type":"bytes32"}],"name":"TokenRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pauser","type":"address"}],"name":"TradingPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pauser","type":"address"}],"name":"TradingUnpaused","type":"event"},{"inputs":[{"internalType":"address","name":"admin_","type":"address"}],"name":"addAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator_","type":"address"}],"name":"addOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"admins","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"}],"name":"cancelOrder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order[]","name":"orders","type":"tuple[]"}],"name":"cancelOrders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"domainSeparator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"},{"internalType":"uint256","name":"fillAmount","type":"uint256"}],"name":"fillOrder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order[]","name":"orders","type":"tuple[]"},{"internalType":"uint256[]","name":"fillAmounts","type":"uint256[]"}],"name":"fillOrders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCollateral","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"token","type":"uint256"}],"name":"getComplement","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"token","type":"uint256"}],"name":"getConditionId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCtf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxFeeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"getOrderStatus","outputs":[{"components":[{"internalType":"bool","name":"isFilledOrCancelled","type":"bool"},{"internalType":"uint256","name":"remaining","type":"uint256"}],"internalType":"struct OrderStatus","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPolyProxyFactoryImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getPolyProxyWalletAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getProxyFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getSafeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSafeFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSafeFactoryImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"}],"name":"hashOrder","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"incrementNonce","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"usr","type":"address"}],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"usr","type":"address"}],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"usr","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"isValidNonce","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"takerOrder","type":"tuple"},{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order[]","name":"makerOrders","type":"tuple[]"},{"internalType":"uint256","name":"takerFillAmount","type":"uint256"},{"internalType":"uint256[]","name":"makerFillAmounts","type":"uint256[]"}],"name":"matchOrders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"operators","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"orderStatus","outputs":[{"internalType":"bool","name":"isFilledOrCancelled","type":"bool"},{"internalType":"uint256","name":"remaining","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"parentCollectionId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxyFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"token","type":"uint256"},{"internalType":"uint256","name":"complement","type":"uint256"},{"internalType":"bytes32","name":"conditionId","type":"bytes32"}],"name":"registerToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"registry","outputs":[{"internalType":"uint256","name":"complement","type":"uint256"},{"internalType":"bytes32","name":"conditionId","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"removeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"removeOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceAdminRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOperatorRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"safeFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newProxyFactory","type":"address"}],"name":"setProxyFactory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newSafeFactory","type":"address"}],"name":"setSafeFactory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpauseTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"token","type":"uint256"},{"internalType":"uint256","name":"complement","type":"uint256"}],"name":"validateComplement","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"}],"name":"validateOrder","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"}],"name":"validateOrderSignature","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"validateTokenId","outputs":[],"stateMutability":"view","type":"function"}] \ No newline at end of file diff --git a/provider/ethereum/contract/polymarket/abi/ConditionTokens.abi b/provider/ethereum/contract/polymarket/abi/ConditionTokens.abi new file mode 100644 index 00000000..3aba6b63 --- /dev/null +++ b/provider/ethereum/contract/polymarket/abi/ConditionTokens.abi @@ -0,0 +1 @@ +[{"constant":true,"inputs":[{"name":"owner","type":"address"},{"name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"collateralToken","type":"address"},{"name":"parentCollectionId","type":"bytes32"},{"name":"conditionId","type":"bytes32"},{"name":"indexSets","type":"uint256[]"}],"name":"redeemPositions","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"},{"name":"","type":"uint256"}],"name":"payoutNumerators","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"from","type":"address"},{"name":"to","type":"address"},{"name":"ids","type":"uint256[]"},{"name":"values","type":"uint256[]"},{"name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"collateralToken","type":"address"},{"name":"collectionId","type":"bytes32"}],"name":"getPositionId","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[{"name":"owners","type":"address[]"},{"name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"name":"","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"collateralToken","type":"address"},{"name":"parentCollectionId","type":"bytes32"},{"name":"conditionId","type":"bytes32"},{"name":"partition","type":"uint256[]"},{"name":"amount","type":"uint256"}],"name":"splitPosition","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"oracle","type":"address"},{"name":"questionId","type":"bytes32"},{"name":"outcomeSlotCount","type":"uint256"}],"name":"getConditionId","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[{"name":"parentCollectionId","type":"bytes32"},{"name":"conditionId","type":"bytes32"},{"name":"indexSet","type":"uint256"}],"name":"getCollectionId","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"collateralToken","type":"address"},{"name":"parentCollectionId","type":"bytes32"},{"name":"conditionId","type":"bytes32"},{"name":"partition","type":"uint256[]"},{"name":"amount","type":"uint256"}],"name":"mergePositions","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"operator","type":"address"},{"name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"questionId","type":"bytes32"},{"name":"payouts","type":"uint256[]"}],"name":"reportPayouts","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"conditionId","type":"bytes32"}],"name":"getOutcomeSlotCount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"oracle","type":"address"},{"name":"questionId","type":"bytes32"},{"name":"outcomeSlotCount","type":"uint256"}],"name":"prepareCondition","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"payoutDenominator","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"owner","type":"address"},{"name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"from","type":"address"},{"name":"to","type":"address"},{"name":"id","type":"uint256"},{"name":"value","type":"uint256"},{"name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"anonymous":false,"inputs":[{"indexed":true,"name":"conditionId","type":"bytes32"},{"indexed":true,"name":"oracle","type":"address"},{"indexed":true,"name":"questionId","type":"bytes32"},{"indexed":false,"name":"outcomeSlotCount","type":"uint256"}],"name":"ConditionPreparation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"conditionId","type":"bytes32"},{"indexed":true,"name":"oracle","type":"address"},{"indexed":true,"name":"questionId","type":"bytes32"},{"indexed":false,"name":"outcomeSlotCount","type":"uint256"},{"indexed":false,"name":"payoutNumerators","type":"uint256[]"}],"name":"ConditionResolution","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"stakeholder","type":"address"},{"indexed":false,"name":"collateralToken","type":"address"},{"indexed":true,"name":"parentCollectionId","type":"bytes32"},{"indexed":true,"name":"conditionId","type":"bytes32"},{"indexed":false,"name":"partition","type":"uint256[]"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"PositionSplit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"stakeholder","type":"address"},{"indexed":false,"name":"collateralToken","type":"address"},{"indexed":true,"name":"parentCollectionId","type":"bytes32"},{"indexed":true,"name":"conditionId","type":"bytes32"},{"indexed":false,"name":"partition","type":"uint256[]"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"PositionsMerge","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"redeemer","type":"address"},{"indexed":true,"name":"collateralToken","type":"address"},{"indexed":true,"name":"parentCollectionId","type":"bytes32"},{"indexed":false,"name":"conditionId","type":"bytes32"},{"indexed":false,"name":"indexSets","type":"uint256[]"},{"indexed":false,"name":"payout","type":"uint256"}],"name":"PayoutRedemption","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"operator","type":"address"},{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"id","type":"uint256"},{"indexed":false,"name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"operator","type":"address"},{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"ids","type":"uint256[]"},{"indexed":false,"name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"operator","type":"address"},{"indexed":false,"name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"value","type":"string"},{"indexed":true,"name":"id","type":"uint256"}],"name":"URI","type":"event"}] \ No newline at end of file diff --git a/provider/ethereum/contract/polymarket/abi/NegRiskCTFExchange.abi b/provider/ethereum/contract/polymarket/abi/NegRiskCTFExchange.abi new file mode 100644 index 00000000..72635104 --- /dev/null +++ b/provider/ethereum/contract/polymarket/abi/NegRiskCTFExchange.abi @@ -0,0 +1 @@ +[{"inputs":[{"internalType":"address","name":"_collateral","type":"address"},{"internalType":"address","name":"_ctf","type":"address"},{"internalType":"address","name":"_negRiskAdapter","type":"address"},{"internalType":"address","name":"_proxyFactory","type":"address"},{"internalType":"address","name":"_safeFactory","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyRegistered","type":"error"},{"inputs":[],"name":"FeeTooHigh","type":"error"},{"inputs":[],"name":"InvalidComplement","type":"error"},{"inputs":[],"name":"InvalidNonce","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[],"name":"InvalidTokenId","type":"error"},{"inputs":[],"name":"MakingGtRemaining","type":"error"},{"inputs":[],"name":"MismatchedTokenIds","type":"error"},{"inputs":[],"name":"NotAdmin","type":"error"},{"inputs":[],"name":"NotCrossing","type":"error"},{"inputs":[],"name":"NotOperator","type":"error"},{"inputs":[],"name":"NotOwner","type":"error"},{"inputs":[],"name":"NotTaker","type":"error"},{"inputs":[],"name":"OrderExpired","type":"error"},{"inputs":[],"name":"OrderFilledOrCancelled","type":"error"},{"inputs":[],"name":"Paused","type":"error"},{"inputs":[],"name":"TooLittleTokensReceived","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeCharged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAdminAddress","type":"address"},{"indexed":true,"internalType":"address","name":"admin","type":"address"}],"name":"NewAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newOperatorAddress","type":"address"},{"indexed":true,"internalType":"address","name":"admin","type":"address"}],"name":"NewOperator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"OrderCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"maker","type":"address"},{"indexed":true,"internalType":"address","name":"taker","type":"address"},{"indexed":false,"internalType":"uint256","name":"makerAssetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerAssetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"makerAmountFilled","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerAmountFilled","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"OrderFilled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"takerOrderHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"takerOrderMaker","type":"address"},{"indexed":false,"internalType":"uint256","name":"makerAssetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerAssetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"makerAmountFilled","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"takerAmountFilled","type":"uint256"}],"name":"OrdersMatched","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldProxyFactory","type":"address"},{"indexed":true,"internalType":"address","name":"newProxyFactory","type":"address"}],"name":"ProxyFactoryUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"removedAdmin","type":"address"},{"indexed":true,"internalType":"address","name":"admin","type":"address"}],"name":"RemovedAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"removedOperator","type":"address"},{"indexed":true,"internalType":"address","name":"admin","type":"address"}],"name":"RemovedOperator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldSafeFactory","type":"address"},{"indexed":true,"internalType":"address","name":"newSafeFactory","type":"address"}],"name":"SafeFactoryUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"token0","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"token1","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"conditionId","type":"bytes32"}],"name":"TokenRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pauser","type":"address"}],"name":"TradingPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pauser","type":"address"}],"name":"TradingUnpaused","type":"event"},{"inputs":[{"internalType":"address","name":"admin_","type":"address"}],"name":"addAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator_","type":"address"}],"name":"addOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"admins","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"}],"name":"cancelOrder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order[]","name":"orders","type":"tuple[]"}],"name":"cancelOrders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"domainSeparator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"},{"internalType":"uint256","name":"fillAmount","type":"uint256"}],"name":"fillOrder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order[]","name":"orders","type":"tuple[]"},{"internalType":"uint256[]","name":"fillAmounts","type":"uint256[]"}],"name":"fillOrders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCollateral","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"token","type":"uint256"}],"name":"getComplement","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"token","type":"uint256"}],"name":"getConditionId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCtf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxFeeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"getOrderStatus","outputs":[{"components":[{"internalType":"bool","name":"isFilledOrCancelled","type":"bool"},{"internalType":"uint256","name":"remaining","type":"uint256"}],"internalType":"struct OrderStatus","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPolyProxyFactoryImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getPolyProxyWalletAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getProxyFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getSafeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSafeFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSafeFactoryImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"}],"name":"hashOrder","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"incrementNonce","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"usr","type":"address"}],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"usr","type":"address"}],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"usr","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"isValidNonce","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"takerOrder","type":"tuple"},{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order[]","name":"makerOrders","type":"tuple[]"},{"internalType":"uint256","name":"takerFillAmount","type":"uint256"},{"internalType":"uint256[]","name":"makerFillAmounts","type":"uint256[]"}],"name":"matchOrders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"operators","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"orderStatus","outputs":[{"internalType":"bool","name":"isFilledOrCancelled","type":"bool"},{"internalType":"uint256","name":"remaining","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"parentCollectionId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxyFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"token","type":"uint256"},{"internalType":"uint256","name":"complement","type":"uint256"},{"internalType":"bytes32","name":"conditionId","type":"bytes32"}],"name":"registerToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"registry","outputs":[{"internalType":"uint256","name":"complement","type":"uint256"},{"internalType":"bytes32","name":"conditionId","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"removeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"removeOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceAdminRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOperatorRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"safeFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newProxyFactory","type":"address"}],"name":"setProxyFactory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newSafeFactory","type":"address"}],"name":"setSafeFactory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpauseTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"token","type":"uint256"},{"internalType":"uint256","name":"complement","type":"uint256"}],"name":"validateComplement","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"}],"name":"validateOrder","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"components":[{"internalType":"uint256","name":"salt","type":"uint256"},{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"makerAmount","type":"uint256"},{"internalType":"uint256","name":"takerAmount","type":"uint256"},{"internalType":"uint256","name":"expiration","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"feeRateBps","type":"uint256"},{"internalType":"enum Side","name":"side","type":"uint8"},{"internalType":"enum SignatureType","name":"signatureType","type":"uint8"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct Order","name":"order","type":"tuple"}],"name":"validateOrderSignature","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"validateTokenId","outputs":[],"stateMutability":"view","type":"function"}] \ No newline at end of file diff --git a/provider/ethereum/contract/polymarket/contract.go b/provider/ethereum/contract/polymarket/contract.go new file mode 100644 index 00000000..fe5a296e --- /dev/null +++ b/provider/ethereum/contract/polymarket/contract.go @@ -0,0 +1,25 @@ +package polymarket + +import ( + "github.com/ethereum/go-ethereum/common" + "github.com/rss3-network/node/provider/ethereum/contract" +) + +// CTF Exchange +// https://polygonscan.com/address/0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e +//go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/CTFExchange.abi --pkg polymarket --type CTFExchange --out contract_ctf_exchange.go +// Neg Risk CTF Exchange +// https://polygonscan.com/address/0xc5d563a36ae78145c45a50134d48a1215220f80a +//go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/NegRiskCTFExchange.abi --pkg polymarket --type NegRiskCTFExchange --out contract_neg_risk_ctf_exchange.go +// Condition Tokens +// https://polygonscan.com/address/0x4D97DCd97eC945f40cF65F87097ACe5EA0476045 +//go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/ConditionTokens.abi --pkg polymarket --type ConditionTokens --out contract_condition_tokens.go + +var ( + AddressPolyMarketCTFExchange = common.HexToAddress("0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E") + AddressPolyMarketNegRiskCTFExchange = common.HexToAddress("0xC5d563A36AE78145C45a50134d48A1215220f80a") + AddressPolyMarketConditionTokens = common.HexToAddress("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045") + + // EventOrderMatched = contract.EventHash("OrdersMatched(bytes32,address,uint256,uint256,uint256,uint256)") + EventOrderFinalized = contract.EventHash("OrderFilled(bytes32,address,address,uint256,uint256,uint256,uint256,uint256)") +) diff --git a/schema/worker/decentralized/platform.go b/schema/worker/decentralized/platform.go index 2794d98c..7bfceea4 100644 --- a/schema/worker/decentralized/platform.go +++ b/schema/worker/decentralized/platform.go @@ -32,6 +32,7 @@ const ( PlatformOptimism // Optimism PlatformParagraph // Paragraph PlatformParaswap // Paraswap + PlatformPolymarket // Polymarket PlatformRSS3 // RSS3 PlatformSAVM // SAVM PlatformStargate // Stargate @@ -77,6 +78,7 @@ var ToPlatformMap = map[Worker]Platform{ Optimism: PlatformOptimism, Paragraph: PlatformParagraph, Paraswap: PlatformParaswap, + Polymarket: PlatformPolymarket, RSS3: PlatformRSS3, SAVM: PlatformSAVM, Stargate: PlatformStargate, diff --git a/schema/worker/decentralized/platform_string.go b/schema/worker/decentralized/platform_string.go index de98cf72..9dea5938 100644 --- a/schema/worker/decentralized/platform_string.go +++ b/schema/worker/decentralized/platform_string.go @@ -9,11 +9,11 @@ import ( "strings" ) -const _PlatformName = "Unknown1inchAAVEAavegotchiArbitrumBaseBendDAOCowCrossbellCurveENSFarcasterHighlightIQWikiKiwiStandLensLidoLinearLooksRareMattersMirrorNounsOpenSeaOptimismParagraphParaswapRSS3SAVMStargateUniswapVSL" +const _PlatformName = "Unknown1inchAAVEAavegotchiArbitrumBaseBendDAOCowCrossbellCurveENSFarcasterHighlightIQWikiKiwiStandLensLidoLinearLooksRareMattersMirrorNounsOpenSeaOptimismParagraphParaswapPolymarketRSS3SAVMStargateUniswapVSL" -var _PlatformIndex = [...]uint8{0, 7, 12, 16, 26, 34, 38, 45, 48, 57, 62, 65, 74, 83, 89, 98, 102, 106, 112, 121, 128, 134, 139, 146, 154, 163, 171, 175, 179, 187, 194, 197} +var _PlatformIndex = [...]uint8{0, 7, 12, 16, 26, 34, 38, 45, 48, 57, 62, 65, 74, 83, 89, 98, 102, 106, 112, 121, 128, 134, 139, 146, 154, 163, 171, 181, 185, 189, 197, 204, 207} -const _PlatformLowerName = "unknown1inchaaveaavegotchiarbitrumbasebenddaocowcrossbellcurveensfarcasterhighlightiqwikikiwistandlenslidolinearlooksraremattersmirrornounsopenseaoptimismparagraphparaswaprss3savmstargateuniswapvsl" +const _PlatformLowerName = "unknown1inchaaveaavegotchiarbitrumbasebenddaocowcrossbellcurveensfarcasterhighlightiqwikikiwistandlenslidolinearlooksraremattersmirrornounsopenseaoptimismparagraphparaswappolymarketrss3savmstargateuniswapvsl" func (i Platform) String() string { if i >= Platform(len(_PlatformIndex)-1) { @@ -56,14 +56,15 @@ func _PlatformNoOp() { _ = x[PlatformOptimism-(23)] _ = x[PlatformParagraph-(24)] _ = x[PlatformParaswap-(25)] - _ = x[PlatformRSS3-(26)] - _ = x[PlatformSAVM-(27)] - _ = x[PlatformStargate-(28)] - _ = x[PlatformUniswap-(29)] - _ = x[PlatformVSL-(30)] + _ = x[PlatformPolymarket-(26)] + _ = x[PlatformRSS3-(27)] + _ = x[PlatformSAVM-(28)] + _ = x[PlatformStargate-(29)] + _ = x[PlatformUniswap-(30)] + _ = x[PlatformVSL-(31)] } -var _PlatformValues = []Platform{PlatformUnknown, Platform1Inch, PlatformAAVE, PlatformAavegotchi, PlatformArbitrum, PlatformBase, PlatformBendDAO, PlatformCow, PlatformCrossbell, PlatformCurve, PlatformENS, PlatformFarcaster, PlatformHighlight, PlatformIQWiki, PlatformKiwiStand, PlatformLens, PlatformLido, PlatformLinea, PlatformLooksRare, PlatformMatters, PlatformMirror, PlatformNouns, PlatformOpenSea, PlatformOptimism, PlatformParagraph, PlatformParaswap, PlatformRSS3, PlatformSAVM, PlatformStargate, PlatformUniswap, PlatformVSL} +var _PlatformValues = []Platform{PlatformUnknown, Platform1Inch, PlatformAAVE, PlatformAavegotchi, PlatformArbitrum, PlatformBase, PlatformBendDAO, PlatformCow, PlatformCrossbell, PlatformCurve, PlatformENS, PlatformFarcaster, PlatformHighlight, PlatformIQWiki, PlatformKiwiStand, PlatformLens, PlatformLido, PlatformLinea, PlatformLooksRare, PlatformMatters, PlatformMirror, PlatformNouns, PlatformOpenSea, PlatformOptimism, PlatformParagraph, PlatformParaswap, PlatformPolymarket, PlatformRSS3, PlatformSAVM, PlatformStargate, PlatformUniswap, PlatformVSL} var _PlatformNameToValueMap = map[string]Platform{ _PlatformName[0:7]: PlatformUnknown, @@ -118,16 +119,18 @@ var _PlatformNameToValueMap = map[string]Platform{ _PlatformLowerName[154:163]: PlatformParagraph, _PlatformName[163:171]: PlatformParaswap, _PlatformLowerName[163:171]: PlatformParaswap, - _PlatformName[171:175]: PlatformRSS3, - _PlatformLowerName[171:175]: PlatformRSS3, - _PlatformName[175:179]: PlatformSAVM, - _PlatformLowerName[175:179]: PlatformSAVM, - _PlatformName[179:187]: PlatformStargate, - _PlatformLowerName[179:187]: PlatformStargate, - _PlatformName[187:194]: PlatformUniswap, - _PlatformLowerName[187:194]: PlatformUniswap, - _PlatformName[194:197]: PlatformVSL, - _PlatformLowerName[194:197]: PlatformVSL, + _PlatformName[171:181]: PlatformPolymarket, + _PlatformLowerName[171:181]: PlatformPolymarket, + _PlatformName[181:185]: PlatformRSS3, + _PlatformLowerName[181:185]: PlatformRSS3, + _PlatformName[185:189]: PlatformSAVM, + _PlatformLowerName[185:189]: PlatformSAVM, + _PlatformName[189:197]: PlatformStargate, + _PlatformLowerName[189:197]: PlatformStargate, + _PlatformName[197:204]: PlatformUniswap, + _PlatformLowerName[197:204]: PlatformUniswap, + _PlatformName[204:207]: PlatformVSL, + _PlatformLowerName[204:207]: PlatformVSL, } var _PlatformNames = []string{ @@ -157,11 +160,12 @@ var _PlatformNames = []string{ _PlatformName[146:154], _PlatformName[154:163], _PlatformName[163:171], - _PlatformName[171:175], - _PlatformName[175:179], - _PlatformName[179:187], - _PlatformName[187:194], - _PlatformName[194:197], + _PlatformName[171:181], + _PlatformName[181:185], + _PlatformName[185:189], + _PlatformName[189:197], + _PlatformName[197:204], + _PlatformName[204:207], } // PlatformString retrieves an enum value from the enum constants string name. diff --git a/schema/worker/decentralized/worker.go b/schema/worker/decentralized/worker.go index 207ac0e6..6d20b41d 100644 --- a/schema/worker/decentralized/worker.go +++ b/schema/worker/decentralized/worker.go @@ -35,6 +35,7 @@ const ( Optimism // optimism Paragraph // paragraph Paraswap // paraswap + Polymarket // polymarket RSS3 // rss3 SAVM // savm Stargate // stargate @@ -92,6 +93,7 @@ var ToTagsMap = map[Worker][]tag.Tag{ Optimism: {tag.Transaction}, Paragraph: {tag.Social}, Paraswap: {tag.Exchange}, + Polymarket: {tag.Exchange}, RSS3: {tag.Exchange, tag.Collectible}, SAVM: {tag.Transaction}, Stargate: {tag.Transaction}, diff --git a/schema/worker/decentralized/worker_string.go b/schema/worker/decentralized/worker_string.go index cda95e48..06c59c39 100644 --- a/schema/worker/decentralized/worker_string.go +++ b/schema/worker/decentralized/worker_string.go @@ -9,11 +9,11 @@ import ( "strings" ) -const _WorkerName = "aaveaavegotchiarbitrumbasebenddaocorecowcrossbellcurveenshighlightiqwikikiwistandlenslidolinealooksraremattersmirrormomokanouns1inchopenseaoptimismparagraphparaswaprss3savmstargateuniswapvsl" +const _WorkerName = "aaveaavegotchiarbitrumbasebenddaocorecowcrossbellcurveenshighlightiqwikikiwistandlenslidolinealooksraremattersmirrormomokanouns1inchopenseaoptimismparagraphparaswappolymarketrss3savmstargateuniswapvsl" -var _WorkerIndex = [...]uint8{0, 4, 14, 22, 26, 33, 37, 40, 49, 54, 57, 66, 72, 81, 85, 89, 94, 103, 110, 116, 122, 127, 132, 139, 147, 156, 164, 168, 172, 180, 187, 190} +var _WorkerIndex = [...]uint8{0, 4, 14, 22, 26, 33, 37, 40, 49, 54, 57, 66, 72, 81, 85, 89, 94, 103, 110, 116, 122, 127, 132, 139, 147, 156, 164, 174, 178, 182, 190, 197, 200} -const _WorkerLowerName = "aaveaavegotchiarbitrumbasebenddaocorecowcrossbellcurveenshighlightiqwikikiwistandlenslidolinealooksraremattersmirrormomokanouns1inchopenseaoptimismparagraphparaswaprss3savmstargateuniswapvsl" +const _WorkerLowerName = "aaveaavegotchiarbitrumbasebenddaocorecowcrossbellcurveenshighlightiqwikikiwistandlenslidolinealooksraremattersmirrormomokanouns1inchopenseaoptimismparagraphparaswappolymarketrss3savmstargateuniswapvsl" func (i Worker) String() string { i -= 1 @@ -57,14 +57,15 @@ func _WorkerNoOp() { _ = x[Optimism-(24)] _ = x[Paragraph-(25)] _ = x[Paraswap-(26)] - _ = x[RSS3-(27)] - _ = x[SAVM-(28)] - _ = x[Stargate-(29)] - _ = x[Uniswap-(30)] - _ = x[VSL-(31)] + _ = x[Polymarket-(27)] + _ = x[RSS3-(28)] + _ = x[SAVM-(29)] + _ = x[Stargate-(30)] + _ = x[Uniswap-(31)] + _ = x[VSL-(32)] } -var _WorkerValues = []Worker{Aave, Aavegotchi, Arbitrum, Base, BendDAO, Core, Cow, Crossbell, Curve, ENS, Highlight, IQWiki, KiwiStand, Lens, Lido, Linea, Looksrare, Matters, Mirror, Momoka, Nouns, Oneinch, OpenSea, Optimism, Paragraph, Paraswap, RSS3, SAVM, Stargate, Uniswap, VSL} +var _WorkerValues = []Worker{Aave, Aavegotchi, Arbitrum, Base, BendDAO, Core, Cow, Crossbell, Curve, ENS, Highlight, IQWiki, KiwiStand, Lens, Lido, Linea, Looksrare, Matters, Mirror, Momoka, Nouns, Oneinch, OpenSea, Optimism, Paragraph, Paraswap, Polymarket, RSS3, SAVM, Stargate, Uniswap, VSL} var _WorkerNameToValueMap = map[string]Worker{ _WorkerName[0:4]: Aave, @@ -119,16 +120,18 @@ var _WorkerNameToValueMap = map[string]Worker{ _WorkerLowerName[147:156]: Paragraph, _WorkerName[156:164]: Paraswap, _WorkerLowerName[156:164]: Paraswap, - _WorkerName[164:168]: RSS3, - _WorkerLowerName[164:168]: RSS3, - _WorkerName[168:172]: SAVM, - _WorkerLowerName[168:172]: SAVM, - _WorkerName[172:180]: Stargate, - _WorkerLowerName[172:180]: Stargate, - _WorkerName[180:187]: Uniswap, - _WorkerLowerName[180:187]: Uniswap, - _WorkerName[187:190]: VSL, - _WorkerLowerName[187:190]: VSL, + _WorkerName[164:174]: Polymarket, + _WorkerLowerName[164:174]: Polymarket, + _WorkerName[174:178]: RSS3, + _WorkerLowerName[174:178]: RSS3, + _WorkerName[178:182]: SAVM, + _WorkerLowerName[178:182]: SAVM, + _WorkerName[182:190]: Stargate, + _WorkerLowerName[182:190]: Stargate, + _WorkerName[190:197]: Uniswap, + _WorkerLowerName[190:197]: Uniswap, + _WorkerName[197:200]: VSL, + _WorkerLowerName[197:200]: VSL, } var _WorkerNames = []string{ @@ -158,11 +161,12 @@ var _WorkerNames = []string{ _WorkerName[139:147], _WorkerName[147:156], _WorkerName[156:164], - _WorkerName[164:168], - _WorkerName[168:172], - _WorkerName[172:180], - _WorkerName[180:187], - _WorkerName[187:190], + _WorkerName[164:174], + _WorkerName[174:178], + _WorkerName[178:182], + _WorkerName[182:190], + _WorkerName[190:197], + _WorkerName[197:200], } // WorkerString retrieves an enum value from the enum constants string name. From 7386c4f259aa34014ee99817be0e986bd9c7c776 Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 16:55:49 +0800 Subject: [PATCH 03/19] feat: generated contract go files --- .../polymarket/contract_condition_tokens.go | 2112 ++++++++++ .../polymarket/contract_ctf_exchange.go | 3566 +++++++++++++++++ .../contract_neg_risk_ctf_exchange.go | 3566 +++++++++++++++++ 3 files changed, 9244 insertions(+) create mode 100644 provider/ethereum/contract/polymarket/contract_condition_tokens.go create mode 100644 provider/ethereum/contract/polymarket/contract_ctf_exchange.go create mode 100644 provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go diff --git a/provider/ethereum/contract/polymarket/contract_condition_tokens.go b/provider/ethereum/contract/polymarket/contract_condition_tokens.go new file mode 100644 index 00000000..b391d33e --- /dev/null +++ b/provider/ethereum/contract/polymarket/contract_condition_tokens.go @@ -0,0 +1,2112 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polymarket + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ConditionTokensMetaData contains all meta data concerning the ConditionTokens contract. +var ConditionTokensMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"indexSets\",\"type\":\"uint256[]\"}],\"name\":\"redeemPositions\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\"},{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"payoutNumerators\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"ids\",\"type\":\"uint256[]\"},{\"name\":\"values\",\"type\":\"uint256[]\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeBatchTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"collectionId\",\"type\":\"bytes32\"}],\"name\":\"getPositionId\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owners\",\"type\":\"address[]\"},{\"name\":\"ids\",\"type\":\"uint256[]\"}],\"name\":\"balanceOfBatch\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"partition\",\"type\":\"uint256[]\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"splitPosition\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"oracle\",\"type\":\"address\"},{\"name\":\"questionId\",\"type\":\"bytes32\"},{\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"indexSet\",\"type\":\"uint256\"}],\"name\":\"getCollectionId\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"partition\",\"type\":\"uint256[]\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mergePositions\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"questionId\",\"type\":\"bytes32\"},{\"name\":\"payouts\",\"type\":\"uint256[]\"}],\"name\":\"reportPayouts\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"getOutcomeSlotCount\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"oracle\",\"type\":\"address\"},{\"name\":\"questionId\",\"type\":\"bytes32\"},{\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"}],\"name\":\"prepareCondition\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"payoutDenominator\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"id\",\"type\":\"uint256\"},{\"name\":\"value\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"oracle\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"questionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"}],\"name\":\"ConditionPreparation\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"oracle\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"questionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"payoutNumerators\",\"type\":\"uint256[]\"}],\"name\":\"ConditionResolution\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"stakeholder\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"collateralToken\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"partition\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"PositionSplit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"stakeholder\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"collateralToken\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"partition\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"PositionsMerge\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"redeemer\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"collateralToken\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"indexSets\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"payout\",\"type\":\"uint256\"}],\"name\":\"PayoutRedemption\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"id\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"TransferSingle\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"ids\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"values\",\"type\":\"uint256[]\"}],\"name\":\"TransferBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"value\",\"type\":\"string\"},{\"indexed\":true,\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"URI\",\"type\":\"event\"}]", +} + +// ConditionTokensABI is the input ABI used to generate the binding from. +// Deprecated: Use ConditionTokensMetaData.ABI instead. +var ConditionTokensABI = ConditionTokensMetaData.ABI + +// ConditionTokens is an auto generated Go binding around an Ethereum contract. +type ConditionTokens struct { + ConditionTokensCaller // Read-only binding to the contract + ConditionTokensTransactor // Write-only binding to the contract + ConditionTokensFilterer // Log filterer for contract events +} + +// ConditionTokensCaller is an auto generated read-only Go binding around an Ethereum contract. +type ConditionTokensCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConditionTokensTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ConditionTokensTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConditionTokensFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ConditionTokensFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConditionTokensSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ConditionTokensSession struct { + Contract *ConditionTokens // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ConditionTokensCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ConditionTokensCallerSession struct { + Contract *ConditionTokensCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ConditionTokensTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ConditionTokensTransactorSession struct { + Contract *ConditionTokensTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ConditionTokensRaw is an auto generated low-level Go binding around an Ethereum contract. +type ConditionTokensRaw struct { + Contract *ConditionTokens // Generic contract binding to access the raw methods on +} + +// ConditionTokensCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ConditionTokensCallerRaw struct { + Contract *ConditionTokensCaller // Generic read-only contract binding to access the raw methods on +} + +// ConditionTokensTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ConditionTokensTransactorRaw struct { + Contract *ConditionTokensTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewConditionTokens creates a new instance of ConditionTokens, bound to a specific deployed contract. +func NewConditionTokens(address common.Address, backend bind.ContractBackend) (*ConditionTokens, error) { + contract, err := bindConditionTokens(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ConditionTokens{ConditionTokensCaller: ConditionTokensCaller{contract: contract}, ConditionTokensTransactor: ConditionTokensTransactor{contract: contract}, ConditionTokensFilterer: ConditionTokensFilterer{contract: contract}}, nil +} + +// NewConditionTokensCaller creates a new read-only instance of ConditionTokens, bound to a specific deployed contract. +func NewConditionTokensCaller(address common.Address, caller bind.ContractCaller) (*ConditionTokensCaller, error) { + contract, err := bindConditionTokens(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ConditionTokensCaller{contract: contract}, nil +} + +// NewConditionTokensTransactor creates a new write-only instance of ConditionTokens, bound to a specific deployed contract. +func NewConditionTokensTransactor(address common.Address, transactor bind.ContractTransactor) (*ConditionTokensTransactor, error) { + contract, err := bindConditionTokens(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ConditionTokensTransactor{contract: contract}, nil +} + +// NewConditionTokensFilterer creates a new log filterer instance of ConditionTokens, bound to a specific deployed contract. +func NewConditionTokensFilterer(address common.Address, filterer bind.ContractFilterer) (*ConditionTokensFilterer, error) { + contract, err := bindConditionTokens(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ConditionTokensFilterer{contract: contract}, nil +} + +// bindConditionTokens binds a generic wrapper to an already deployed contract. +func bindConditionTokens(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ConditionTokensMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ConditionTokens *ConditionTokensRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ConditionTokens.Contract.ConditionTokensCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ConditionTokens *ConditionTokensRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ConditionTokens.Contract.ConditionTokensTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ConditionTokens *ConditionTokensRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ConditionTokens.Contract.ConditionTokensTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ConditionTokens *ConditionTokensCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ConditionTokens.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ConditionTokens *ConditionTokensTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ConditionTokens.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ConditionTokens *ConditionTokensTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ConditionTokens.Contract.contract.Transact(opts, method, params...) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e. +// +// Solidity: function balanceOf(address owner, uint256 id) view returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) BalanceOf(opts *bind.CallOpts, owner common.Address, id *big.Int) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "balanceOf", owner, id) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e. +// +// Solidity: function balanceOf(address owner, uint256 id) view returns(uint256) +func (_ConditionTokens *ConditionTokensSession) BalanceOf(owner common.Address, id *big.Int) (*big.Int, error) { + return _ConditionTokens.Contract.BalanceOf(&_ConditionTokens.CallOpts, owner, id) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e. +// +// Solidity: function balanceOf(address owner, uint256 id) view returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) BalanceOf(owner common.Address, id *big.Int) (*big.Int, error) { + return _ConditionTokens.Contract.BalanceOf(&_ConditionTokens.CallOpts, owner, id) +} + +// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4. +// +// Solidity: function balanceOfBatch(address[] owners, uint256[] ids) view returns(uint256[]) +func (_ConditionTokens *ConditionTokensCaller) BalanceOfBatch(opts *bind.CallOpts, owners []common.Address, ids []*big.Int) ([]*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "balanceOfBatch", owners, ids) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4. +// +// Solidity: function balanceOfBatch(address[] owners, uint256[] ids) view returns(uint256[]) +func (_ConditionTokens *ConditionTokensSession) BalanceOfBatch(owners []common.Address, ids []*big.Int) ([]*big.Int, error) { + return _ConditionTokens.Contract.BalanceOfBatch(&_ConditionTokens.CallOpts, owners, ids) +} + +// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4. +// +// Solidity: function balanceOfBatch(address[] owners, uint256[] ids) view returns(uint256[]) +func (_ConditionTokens *ConditionTokensCallerSession) BalanceOfBatch(owners []common.Address, ids []*big.Int) ([]*big.Int, error) { + return _ConditionTokens.Contract.BalanceOfBatch(&_ConditionTokens.CallOpts, owners, ids) +} + +// GetCollectionId is a free data retrieval call binding the contract method 0x856296f7. +// +// Solidity: function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) view returns(bytes32) +func (_ConditionTokens *ConditionTokensCaller) GetCollectionId(opts *bind.CallOpts, parentCollectionId [32]byte, conditionId [32]byte, indexSet *big.Int) ([32]byte, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "getCollectionId", parentCollectionId, conditionId, indexSet) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetCollectionId is a free data retrieval call binding the contract method 0x856296f7. +// +// Solidity: function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) view returns(bytes32) +func (_ConditionTokens *ConditionTokensSession) GetCollectionId(parentCollectionId [32]byte, conditionId [32]byte, indexSet *big.Int) ([32]byte, error) { + return _ConditionTokens.Contract.GetCollectionId(&_ConditionTokens.CallOpts, parentCollectionId, conditionId, indexSet) +} + +// GetCollectionId is a free data retrieval call binding the contract method 0x856296f7. +// +// Solidity: function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) view returns(bytes32) +func (_ConditionTokens *ConditionTokensCallerSession) GetCollectionId(parentCollectionId [32]byte, conditionId [32]byte, indexSet *big.Int) ([32]byte, error) { + return _ConditionTokens.Contract.GetCollectionId(&_ConditionTokens.CallOpts, parentCollectionId, conditionId, indexSet) +} + +// GetConditionId is a free data retrieval call binding the contract method 0x852c6ae2. +// +// Solidity: function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) pure returns(bytes32) +func (_ConditionTokens *ConditionTokensCaller) GetConditionId(opts *bind.CallOpts, oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) ([32]byte, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "getConditionId", oracle, questionId, outcomeSlotCount) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetConditionId is a free data retrieval call binding the contract method 0x852c6ae2. +// +// Solidity: function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) pure returns(bytes32) +func (_ConditionTokens *ConditionTokensSession) GetConditionId(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) ([32]byte, error) { + return _ConditionTokens.Contract.GetConditionId(&_ConditionTokens.CallOpts, oracle, questionId, outcomeSlotCount) +} + +// GetConditionId is a free data retrieval call binding the contract method 0x852c6ae2. +// +// Solidity: function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) pure returns(bytes32) +func (_ConditionTokens *ConditionTokensCallerSession) GetConditionId(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) ([32]byte, error) { + return _ConditionTokens.Contract.GetConditionId(&_ConditionTokens.CallOpts, oracle, questionId, outcomeSlotCount) +} + +// GetOutcomeSlotCount is a free data retrieval call binding the contract method 0xd42dc0c2. +// +// Solidity: function getOutcomeSlotCount(bytes32 conditionId) view returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) GetOutcomeSlotCount(opts *bind.CallOpts, conditionId [32]byte) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "getOutcomeSlotCount", conditionId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetOutcomeSlotCount is a free data retrieval call binding the contract method 0xd42dc0c2. +// +// Solidity: function getOutcomeSlotCount(bytes32 conditionId) view returns(uint256) +func (_ConditionTokens *ConditionTokensSession) GetOutcomeSlotCount(conditionId [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.GetOutcomeSlotCount(&_ConditionTokens.CallOpts, conditionId) +} + +// GetOutcomeSlotCount is a free data retrieval call binding the contract method 0xd42dc0c2. +// +// Solidity: function getOutcomeSlotCount(bytes32 conditionId) view returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) GetOutcomeSlotCount(conditionId [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.GetOutcomeSlotCount(&_ConditionTokens.CallOpts, conditionId) +} + +// GetPositionId is a free data retrieval call binding the contract method 0x39dd7530. +// +// Solidity: function getPositionId(address collateralToken, bytes32 collectionId) pure returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) GetPositionId(opts *bind.CallOpts, collateralToken common.Address, collectionId [32]byte) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "getPositionId", collateralToken, collectionId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetPositionId is a free data retrieval call binding the contract method 0x39dd7530. +// +// Solidity: function getPositionId(address collateralToken, bytes32 collectionId) pure returns(uint256) +func (_ConditionTokens *ConditionTokensSession) GetPositionId(collateralToken common.Address, collectionId [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.GetPositionId(&_ConditionTokens.CallOpts, collateralToken, collectionId) +} + +// GetPositionId is a free data retrieval call binding the contract method 0x39dd7530. +// +// Solidity: function getPositionId(address collateralToken, bytes32 collectionId) pure returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) GetPositionId(collateralToken common.Address, collectionId [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.GetPositionId(&_ConditionTokens.CallOpts, collateralToken, collectionId) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) +func (_ConditionTokens *ConditionTokensCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "isApprovedForAll", owner, operator) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) +func (_ConditionTokens *ConditionTokensSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) { + return _ConditionTokens.Contract.IsApprovedForAll(&_ConditionTokens.CallOpts, owner, operator) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) +func (_ConditionTokens *ConditionTokensCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) { + return _ConditionTokens.Contract.IsApprovedForAll(&_ConditionTokens.CallOpts, owner, operator) +} + +// PayoutDenominator is a free data retrieval call binding the contract method 0xdd34de67. +// +// Solidity: function payoutDenominator(bytes32 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) PayoutDenominator(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "payoutDenominator", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PayoutDenominator is a free data retrieval call binding the contract method 0xdd34de67. +// +// Solidity: function payoutDenominator(bytes32 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensSession) PayoutDenominator(arg0 [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.PayoutDenominator(&_ConditionTokens.CallOpts, arg0) +} + +// PayoutDenominator is a free data retrieval call binding the contract method 0xdd34de67. +// +// Solidity: function payoutDenominator(bytes32 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) PayoutDenominator(arg0 [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.PayoutDenominator(&_ConditionTokens.CallOpts, arg0) +} + +// PayoutNumerators is a free data retrieval call binding the contract method 0x0504c814. +// +// Solidity: function payoutNumerators(bytes32 , uint256 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) PayoutNumerators(opts *bind.CallOpts, arg0 [32]byte, arg1 *big.Int) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "payoutNumerators", arg0, arg1) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PayoutNumerators is a free data retrieval call binding the contract method 0x0504c814. +// +// Solidity: function payoutNumerators(bytes32 , uint256 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensSession) PayoutNumerators(arg0 [32]byte, arg1 *big.Int) (*big.Int, error) { + return _ConditionTokens.Contract.PayoutNumerators(&_ConditionTokens.CallOpts, arg0, arg1) +} + +// PayoutNumerators is a free data retrieval call binding the contract method 0x0504c814. +// +// Solidity: function payoutNumerators(bytes32 , uint256 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) PayoutNumerators(arg0 [32]byte, arg1 *big.Int) (*big.Int, error) { + return _ConditionTokens.Contract.PayoutNumerators(&_ConditionTokens.CallOpts, arg0, arg1) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_ConditionTokens *ConditionTokensCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "supportsInterface", interfaceId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_ConditionTokens *ConditionTokensSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _ConditionTokens.Contract.SupportsInterface(&_ConditionTokens.CallOpts, interfaceId) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_ConditionTokens *ConditionTokensCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _ConditionTokens.Contract.SupportsInterface(&_ConditionTokens.CallOpts, interfaceId) +} + +// MergePositions is a paid mutator transaction binding the contract method 0x9e7212ad. +// +// Solidity: function mergePositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensTransactor) MergePositions(opts *bind.TransactOpts, collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "mergePositions", collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// MergePositions is a paid mutator transaction binding the contract method 0x9e7212ad. +// +// Solidity: function mergePositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensSession) MergePositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.MergePositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// MergePositions is a paid mutator transaction binding the contract method 0x9e7212ad. +// +// Solidity: function mergePositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) MergePositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.MergePositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// PrepareCondition is a paid mutator transaction binding the contract method 0xd96ee754. +// +// Solidity: function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) returns() +func (_ConditionTokens *ConditionTokensTransactor) PrepareCondition(opts *bind.TransactOpts, oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "prepareCondition", oracle, questionId, outcomeSlotCount) +} + +// PrepareCondition is a paid mutator transaction binding the contract method 0xd96ee754. +// +// Solidity: function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) returns() +func (_ConditionTokens *ConditionTokensSession) PrepareCondition(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.PrepareCondition(&_ConditionTokens.TransactOpts, oracle, questionId, outcomeSlotCount) +} + +// PrepareCondition is a paid mutator transaction binding the contract method 0xd96ee754. +// +// Solidity: function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) PrepareCondition(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.PrepareCondition(&_ConditionTokens.TransactOpts, oracle, questionId, outcomeSlotCount) +} + +// RedeemPositions is a paid mutator transaction binding the contract method 0x01b7037c. +// +// Solidity: function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) returns() +func (_ConditionTokens *ConditionTokensTransactor) RedeemPositions(opts *bind.TransactOpts, collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, indexSets []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "redeemPositions", collateralToken, parentCollectionId, conditionId, indexSets) +} + +// RedeemPositions is a paid mutator transaction binding the contract method 0x01b7037c. +// +// Solidity: function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) returns() +func (_ConditionTokens *ConditionTokensSession) RedeemPositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, indexSets []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.RedeemPositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, indexSets) +} + +// RedeemPositions is a paid mutator transaction binding the contract method 0x01b7037c. +// +// Solidity: function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) RedeemPositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, indexSets []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.RedeemPositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, indexSets) +} + +// ReportPayouts is a paid mutator transaction binding the contract method 0xc49298ac. +// +// Solidity: function reportPayouts(bytes32 questionId, uint256[] payouts) returns() +func (_ConditionTokens *ConditionTokensTransactor) ReportPayouts(opts *bind.TransactOpts, questionId [32]byte, payouts []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "reportPayouts", questionId, payouts) +} + +// ReportPayouts is a paid mutator transaction binding the contract method 0xc49298ac. +// +// Solidity: function reportPayouts(bytes32 questionId, uint256[] payouts) returns() +func (_ConditionTokens *ConditionTokensSession) ReportPayouts(questionId [32]byte, payouts []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.ReportPayouts(&_ConditionTokens.TransactOpts, questionId, payouts) +} + +// ReportPayouts is a paid mutator transaction binding the contract method 0xc49298ac. +// +// Solidity: function reportPayouts(bytes32 questionId, uint256[] payouts) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) ReportPayouts(questionId [32]byte, payouts []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.ReportPayouts(&_ConditionTokens.TransactOpts, questionId, payouts) +} + +// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6. +// +// Solidity: function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] values, bytes data) returns() +func (_ConditionTokens *ConditionTokensTransactor) SafeBatchTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ids []*big.Int, values []*big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "safeBatchTransferFrom", from, to, ids, values, data) +} + +// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6. +// +// Solidity: function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] values, bytes data) returns() +func (_ConditionTokens *ConditionTokensSession) SafeBatchTransferFrom(from common.Address, to common.Address, ids []*big.Int, values []*big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.Contract.SafeBatchTransferFrom(&_ConditionTokens.TransactOpts, from, to, ids, values, data) +} + +// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6. +// +// Solidity: function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] values, bytes data) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) SafeBatchTransferFrom(from common.Address, to common.Address, ids []*big.Int, values []*big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.Contract.SafeBatchTransferFrom(&_ConditionTokens.TransactOpts, from, to, ids, values, data) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes data) returns() +func (_ConditionTokens *ConditionTokensTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, id *big.Int, value *big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "safeTransferFrom", from, to, id, value, data) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes data) returns() +func (_ConditionTokens *ConditionTokensSession) SafeTransferFrom(from common.Address, to common.Address, id *big.Int, value *big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.Contract.SafeTransferFrom(&_ConditionTokens.TransactOpts, from, to, id, value, data) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes data) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) SafeTransferFrom(from common.Address, to common.Address, id *big.Int, value *big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.Contract.SafeTransferFrom(&_ConditionTokens.TransactOpts, from, to, id, value, data) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address operator, bool approved) returns() +func (_ConditionTokens *ConditionTokensTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, approved bool) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "setApprovalForAll", operator, approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address operator, bool approved) returns() +func (_ConditionTokens *ConditionTokensSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) { + return _ConditionTokens.Contract.SetApprovalForAll(&_ConditionTokens.TransactOpts, operator, approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address operator, bool approved) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) { + return _ConditionTokens.Contract.SetApprovalForAll(&_ConditionTokens.TransactOpts, operator, approved) +} + +// SplitPosition is a paid mutator transaction binding the contract method 0x72ce4275. +// +// Solidity: function splitPosition(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensTransactor) SplitPosition(opts *bind.TransactOpts, collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "splitPosition", collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// SplitPosition is a paid mutator transaction binding the contract method 0x72ce4275. +// +// Solidity: function splitPosition(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensSession) SplitPosition(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.SplitPosition(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// SplitPosition is a paid mutator transaction binding the contract method 0x72ce4275. +// +// Solidity: function splitPosition(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) SplitPosition(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.SplitPosition(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// ConditionTokensApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ConditionTokens contract. +type ConditionTokensApprovalForAllIterator struct { + Event *ConditionTokensApprovalForAll // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensApprovalForAllIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensApprovalForAllIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensApprovalForAllIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensApprovalForAll represents a ApprovalForAll event raised by the ConditionTokens contract. +type ConditionTokensApprovalForAll struct { + Owner common.Address + Operator common.Address + Approved bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved) +func (_ConditionTokens *ConditionTokensFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ConditionTokensApprovalForAllIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule) + if err != nil { + return nil, err + } + return &ConditionTokensApprovalForAllIterator{contract: _ConditionTokens.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil +} + +// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved) +func (_ConditionTokens *ConditionTokensFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ConditionTokensApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensApprovalForAll) + if err := _ConditionTokens.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved) +func (_ConditionTokens *ConditionTokensFilterer) ParseApprovalForAll(log types.Log) (*ConditionTokensApprovalForAll, error) { + event := new(ConditionTokensApprovalForAll) + if err := _ConditionTokens.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensConditionPreparationIterator is returned from FilterConditionPreparation and is used to iterate over the raw logs and unpacked data for ConditionPreparation events raised by the ConditionTokens contract. +type ConditionTokensConditionPreparationIterator struct { + Event *ConditionTokensConditionPreparation // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensConditionPreparationIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensConditionPreparation) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensConditionPreparation) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensConditionPreparationIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensConditionPreparationIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensConditionPreparation represents a ConditionPreparation event raised by the ConditionTokens contract. +type ConditionTokensConditionPreparation struct { + ConditionId [32]byte + Oracle common.Address + QuestionId [32]byte + OutcomeSlotCount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterConditionPreparation is a free log retrieval operation binding the contract event 0xab3760c3bd2bb38b5bcf54dc79802ed67338b4cf29f3054ded67ed24661e4177. +// +// Solidity: event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount) +func (_ConditionTokens *ConditionTokensFilterer) FilterConditionPreparation(opts *bind.FilterOpts, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (*ConditionTokensConditionPreparationIterator, error) { + + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + var oracleRule []interface{} + for _, oracleItem := range oracle { + oracleRule = append(oracleRule, oracleItem) + } + var questionIdRule []interface{} + for _, questionIdItem := range questionId { + questionIdRule = append(questionIdRule, questionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "ConditionPreparation", conditionIdRule, oracleRule, questionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensConditionPreparationIterator{contract: _ConditionTokens.contract, event: "ConditionPreparation", logs: logs, sub: sub}, nil +} + +// WatchConditionPreparation is a free log subscription operation binding the contract event 0xab3760c3bd2bb38b5bcf54dc79802ed67338b4cf29f3054ded67ed24661e4177. +// +// Solidity: event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount) +func (_ConditionTokens *ConditionTokensFilterer) WatchConditionPreparation(opts *bind.WatchOpts, sink chan<- *ConditionTokensConditionPreparation, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (event.Subscription, error) { + + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + var oracleRule []interface{} + for _, oracleItem := range oracle { + oracleRule = append(oracleRule, oracleItem) + } + var questionIdRule []interface{} + for _, questionIdItem := range questionId { + questionIdRule = append(questionIdRule, questionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "ConditionPreparation", conditionIdRule, oracleRule, questionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensConditionPreparation) + if err := _ConditionTokens.contract.UnpackLog(event, "ConditionPreparation", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseConditionPreparation is a log parse operation binding the contract event 0xab3760c3bd2bb38b5bcf54dc79802ed67338b4cf29f3054ded67ed24661e4177. +// +// Solidity: event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount) +func (_ConditionTokens *ConditionTokensFilterer) ParseConditionPreparation(log types.Log) (*ConditionTokensConditionPreparation, error) { + event := new(ConditionTokensConditionPreparation) + if err := _ConditionTokens.contract.UnpackLog(event, "ConditionPreparation", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensConditionResolutionIterator is returned from FilterConditionResolution and is used to iterate over the raw logs and unpacked data for ConditionResolution events raised by the ConditionTokens contract. +type ConditionTokensConditionResolutionIterator struct { + Event *ConditionTokensConditionResolution // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensConditionResolutionIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensConditionResolution) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensConditionResolution) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensConditionResolutionIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensConditionResolutionIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensConditionResolution represents a ConditionResolution event raised by the ConditionTokens contract. +type ConditionTokensConditionResolution struct { + ConditionId [32]byte + Oracle common.Address + QuestionId [32]byte + OutcomeSlotCount *big.Int + PayoutNumerators []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterConditionResolution is a free log retrieval operation binding the contract event 0xb44d84d3289691f71497564b85d4233648d9dbae8cbdbb4329f301c3a0185894. +// +// Solidity: event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators) +func (_ConditionTokens *ConditionTokensFilterer) FilterConditionResolution(opts *bind.FilterOpts, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (*ConditionTokensConditionResolutionIterator, error) { + + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + var oracleRule []interface{} + for _, oracleItem := range oracle { + oracleRule = append(oracleRule, oracleItem) + } + var questionIdRule []interface{} + for _, questionIdItem := range questionId { + questionIdRule = append(questionIdRule, questionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "ConditionResolution", conditionIdRule, oracleRule, questionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensConditionResolutionIterator{contract: _ConditionTokens.contract, event: "ConditionResolution", logs: logs, sub: sub}, nil +} + +// WatchConditionResolution is a free log subscription operation binding the contract event 0xb44d84d3289691f71497564b85d4233648d9dbae8cbdbb4329f301c3a0185894. +// +// Solidity: event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators) +func (_ConditionTokens *ConditionTokensFilterer) WatchConditionResolution(opts *bind.WatchOpts, sink chan<- *ConditionTokensConditionResolution, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (event.Subscription, error) { + + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + var oracleRule []interface{} + for _, oracleItem := range oracle { + oracleRule = append(oracleRule, oracleItem) + } + var questionIdRule []interface{} + for _, questionIdItem := range questionId { + questionIdRule = append(questionIdRule, questionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "ConditionResolution", conditionIdRule, oracleRule, questionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensConditionResolution) + if err := _ConditionTokens.contract.UnpackLog(event, "ConditionResolution", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseConditionResolution is a log parse operation binding the contract event 0xb44d84d3289691f71497564b85d4233648d9dbae8cbdbb4329f301c3a0185894. +// +// Solidity: event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators) +func (_ConditionTokens *ConditionTokensFilterer) ParseConditionResolution(log types.Log) (*ConditionTokensConditionResolution, error) { + event := new(ConditionTokensConditionResolution) + if err := _ConditionTokens.contract.UnpackLog(event, "ConditionResolution", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensPayoutRedemptionIterator is returned from FilterPayoutRedemption and is used to iterate over the raw logs and unpacked data for PayoutRedemption events raised by the ConditionTokens contract. +type ConditionTokensPayoutRedemptionIterator struct { + Event *ConditionTokensPayoutRedemption // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensPayoutRedemptionIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPayoutRedemption) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPayoutRedemption) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensPayoutRedemptionIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensPayoutRedemptionIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensPayoutRedemption represents a PayoutRedemption event raised by the ConditionTokens contract. +type ConditionTokensPayoutRedemption struct { + Redeemer common.Address + CollateralToken common.Address + ParentCollectionId [32]byte + ConditionId [32]byte + IndexSets []*big.Int + Payout *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPayoutRedemption is a free log retrieval operation binding the contract event 0x2682012a4a4f1973119f1c9b90745d1bd91fa2bab387344f044cb3586864d18d. +// +// Solidity: event PayoutRedemption(address indexed redeemer, address indexed collateralToken, bytes32 indexed parentCollectionId, bytes32 conditionId, uint256[] indexSets, uint256 payout) +func (_ConditionTokens *ConditionTokensFilterer) FilterPayoutRedemption(opts *bind.FilterOpts, redeemer []common.Address, collateralToken []common.Address, parentCollectionId [][32]byte) (*ConditionTokensPayoutRedemptionIterator, error) { + + var redeemerRule []interface{} + for _, redeemerItem := range redeemer { + redeemerRule = append(redeemerRule, redeemerItem) + } + var collateralTokenRule []interface{} + for _, collateralTokenItem := range collateralToken { + collateralTokenRule = append(collateralTokenRule, collateralTokenItem) + } + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "PayoutRedemption", redeemerRule, collateralTokenRule, parentCollectionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensPayoutRedemptionIterator{contract: _ConditionTokens.contract, event: "PayoutRedemption", logs: logs, sub: sub}, nil +} + +// WatchPayoutRedemption is a free log subscription operation binding the contract event 0x2682012a4a4f1973119f1c9b90745d1bd91fa2bab387344f044cb3586864d18d. +// +// Solidity: event PayoutRedemption(address indexed redeemer, address indexed collateralToken, bytes32 indexed parentCollectionId, bytes32 conditionId, uint256[] indexSets, uint256 payout) +func (_ConditionTokens *ConditionTokensFilterer) WatchPayoutRedemption(opts *bind.WatchOpts, sink chan<- *ConditionTokensPayoutRedemption, redeemer []common.Address, collateralToken []common.Address, parentCollectionId [][32]byte) (event.Subscription, error) { + + var redeemerRule []interface{} + for _, redeemerItem := range redeemer { + redeemerRule = append(redeemerRule, redeemerItem) + } + var collateralTokenRule []interface{} + for _, collateralTokenItem := range collateralToken { + collateralTokenRule = append(collateralTokenRule, collateralTokenItem) + } + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "PayoutRedemption", redeemerRule, collateralTokenRule, parentCollectionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensPayoutRedemption) + if err := _ConditionTokens.contract.UnpackLog(event, "PayoutRedemption", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePayoutRedemption is a log parse operation binding the contract event 0x2682012a4a4f1973119f1c9b90745d1bd91fa2bab387344f044cb3586864d18d. +// +// Solidity: event PayoutRedemption(address indexed redeemer, address indexed collateralToken, bytes32 indexed parentCollectionId, bytes32 conditionId, uint256[] indexSets, uint256 payout) +func (_ConditionTokens *ConditionTokensFilterer) ParsePayoutRedemption(log types.Log) (*ConditionTokensPayoutRedemption, error) { + event := new(ConditionTokensPayoutRedemption) + if err := _ConditionTokens.contract.UnpackLog(event, "PayoutRedemption", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensPositionSplitIterator is returned from FilterPositionSplit and is used to iterate over the raw logs and unpacked data for PositionSplit events raised by the ConditionTokens contract. +type ConditionTokensPositionSplitIterator struct { + Event *ConditionTokensPositionSplit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensPositionSplitIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPositionSplit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPositionSplit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensPositionSplitIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensPositionSplitIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensPositionSplit represents a PositionSplit event raised by the ConditionTokens contract. +type ConditionTokensPositionSplit struct { + Stakeholder common.Address + CollateralToken common.Address + ParentCollectionId [32]byte + ConditionId [32]byte + Partition []*big.Int + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPositionSplit is a free log retrieval operation binding the contract event 0x2e6bb91f8cbcda0c93623c54d0403a43514fabc40084ec96b6d5379a74786298. +// +// Solidity: event PositionSplit(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) FilterPositionSplit(opts *bind.FilterOpts, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (*ConditionTokensPositionSplitIterator, error) { + + var stakeholderRule []interface{} + for _, stakeholderItem := range stakeholder { + stakeholderRule = append(stakeholderRule, stakeholderItem) + } + + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "PositionSplit", stakeholderRule, parentCollectionIdRule, conditionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensPositionSplitIterator{contract: _ConditionTokens.contract, event: "PositionSplit", logs: logs, sub: sub}, nil +} + +// WatchPositionSplit is a free log subscription operation binding the contract event 0x2e6bb91f8cbcda0c93623c54d0403a43514fabc40084ec96b6d5379a74786298. +// +// Solidity: event PositionSplit(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) WatchPositionSplit(opts *bind.WatchOpts, sink chan<- *ConditionTokensPositionSplit, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (event.Subscription, error) { + + var stakeholderRule []interface{} + for _, stakeholderItem := range stakeholder { + stakeholderRule = append(stakeholderRule, stakeholderItem) + } + + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "PositionSplit", stakeholderRule, parentCollectionIdRule, conditionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensPositionSplit) + if err := _ConditionTokens.contract.UnpackLog(event, "PositionSplit", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePositionSplit is a log parse operation binding the contract event 0x2e6bb91f8cbcda0c93623c54d0403a43514fabc40084ec96b6d5379a74786298. +// +// Solidity: event PositionSplit(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) ParsePositionSplit(log types.Log) (*ConditionTokensPositionSplit, error) { + event := new(ConditionTokensPositionSplit) + if err := _ConditionTokens.contract.UnpackLog(event, "PositionSplit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensPositionsMergeIterator is returned from FilterPositionsMerge and is used to iterate over the raw logs and unpacked data for PositionsMerge events raised by the ConditionTokens contract. +type ConditionTokensPositionsMergeIterator struct { + Event *ConditionTokensPositionsMerge // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensPositionsMergeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPositionsMerge) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPositionsMerge) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensPositionsMergeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensPositionsMergeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensPositionsMerge represents a PositionsMerge event raised by the ConditionTokens contract. +type ConditionTokensPositionsMerge struct { + Stakeholder common.Address + CollateralToken common.Address + ParentCollectionId [32]byte + ConditionId [32]byte + Partition []*big.Int + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPositionsMerge is a free log retrieval operation binding the contract event 0x6f13ca62553fcc2bcd2372180a43949c1e4cebba603901ede2f4e14f36b282ca. +// +// Solidity: event PositionsMerge(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) FilterPositionsMerge(opts *bind.FilterOpts, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (*ConditionTokensPositionsMergeIterator, error) { + + var stakeholderRule []interface{} + for _, stakeholderItem := range stakeholder { + stakeholderRule = append(stakeholderRule, stakeholderItem) + } + + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "PositionsMerge", stakeholderRule, parentCollectionIdRule, conditionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensPositionsMergeIterator{contract: _ConditionTokens.contract, event: "PositionsMerge", logs: logs, sub: sub}, nil +} + +// WatchPositionsMerge is a free log subscription operation binding the contract event 0x6f13ca62553fcc2bcd2372180a43949c1e4cebba603901ede2f4e14f36b282ca. +// +// Solidity: event PositionsMerge(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) WatchPositionsMerge(opts *bind.WatchOpts, sink chan<- *ConditionTokensPositionsMerge, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (event.Subscription, error) { + + var stakeholderRule []interface{} + for _, stakeholderItem := range stakeholder { + stakeholderRule = append(stakeholderRule, stakeholderItem) + } + + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "PositionsMerge", stakeholderRule, parentCollectionIdRule, conditionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensPositionsMerge) + if err := _ConditionTokens.contract.UnpackLog(event, "PositionsMerge", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePositionsMerge is a log parse operation binding the contract event 0x6f13ca62553fcc2bcd2372180a43949c1e4cebba603901ede2f4e14f36b282ca. +// +// Solidity: event PositionsMerge(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) ParsePositionsMerge(log types.Log) (*ConditionTokensPositionsMerge, error) { + event := new(ConditionTokensPositionsMerge) + if err := _ConditionTokens.contract.UnpackLog(event, "PositionsMerge", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensTransferBatchIterator is returned from FilterTransferBatch and is used to iterate over the raw logs and unpacked data for TransferBatch events raised by the ConditionTokens contract. +type ConditionTokensTransferBatchIterator struct { + Event *ConditionTokensTransferBatch // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensTransferBatchIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensTransferBatch) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensTransferBatch) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensTransferBatchIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensTransferBatchIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensTransferBatch represents a TransferBatch event raised by the ConditionTokens contract. +type ConditionTokensTransferBatch struct { + Operator common.Address + From common.Address + To common.Address + Ids []*big.Int + Values []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransferBatch is a free log retrieval operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb. +// +// Solidity: event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values) +func (_ConditionTokens *ConditionTokensFilterer) FilterTransferBatch(opts *bind.FilterOpts, operator []common.Address, from []common.Address, to []common.Address) (*ConditionTokensTransferBatchIterator, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "TransferBatch", operatorRule, fromRule, toRule) + if err != nil { + return nil, err + } + return &ConditionTokensTransferBatchIterator{contract: _ConditionTokens.contract, event: "TransferBatch", logs: logs, sub: sub}, nil +} + +// WatchTransferBatch is a free log subscription operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb. +// +// Solidity: event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values) +func (_ConditionTokens *ConditionTokensFilterer) WatchTransferBatch(opts *bind.WatchOpts, sink chan<- *ConditionTokensTransferBatch, operator []common.Address, from []common.Address, to []common.Address) (event.Subscription, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "TransferBatch", operatorRule, fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensTransferBatch) + if err := _ConditionTokens.contract.UnpackLog(event, "TransferBatch", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransferBatch is a log parse operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb. +// +// Solidity: event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values) +func (_ConditionTokens *ConditionTokensFilterer) ParseTransferBatch(log types.Log) (*ConditionTokensTransferBatch, error) { + event := new(ConditionTokensTransferBatch) + if err := _ConditionTokens.contract.UnpackLog(event, "TransferBatch", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensTransferSingleIterator is returned from FilterTransferSingle and is used to iterate over the raw logs and unpacked data for TransferSingle events raised by the ConditionTokens contract. +type ConditionTokensTransferSingleIterator struct { + Event *ConditionTokensTransferSingle // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensTransferSingleIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensTransferSingle) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensTransferSingle) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensTransferSingleIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensTransferSingleIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensTransferSingle represents a TransferSingle event raised by the ConditionTokens contract. +type ConditionTokensTransferSingle struct { + Operator common.Address + From common.Address + To common.Address + Id *big.Int + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransferSingle is a free log retrieval operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62. +// +// Solidity: event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value) +func (_ConditionTokens *ConditionTokensFilterer) FilterTransferSingle(opts *bind.FilterOpts, operator []common.Address, from []common.Address, to []common.Address) (*ConditionTokensTransferSingleIterator, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "TransferSingle", operatorRule, fromRule, toRule) + if err != nil { + return nil, err + } + return &ConditionTokensTransferSingleIterator{contract: _ConditionTokens.contract, event: "TransferSingle", logs: logs, sub: sub}, nil +} + +// WatchTransferSingle is a free log subscription operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62. +// +// Solidity: event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value) +func (_ConditionTokens *ConditionTokensFilterer) WatchTransferSingle(opts *bind.WatchOpts, sink chan<- *ConditionTokensTransferSingle, operator []common.Address, from []common.Address, to []common.Address) (event.Subscription, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "TransferSingle", operatorRule, fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensTransferSingle) + if err := _ConditionTokens.contract.UnpackLog(event, "TransferSingle", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransferSingle is a log parse operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62. +// +// Solidity: event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value) +func (_ConditionTokens *ConditionTokensFilterer) ParseTransferSingle(log types.Log) (*ConditionTokensTransferSingle, error) { + event := new(ConditionTokensTransferSingle) + if err := _ConditionTokens.contract.UnpackLog(event, "TransferSingle", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensURIIterator is returned from FilterURI and is used to iterate over the raw logs and unpacked data for URI events raised by the ConditionTokens contract. +type ConditionTokensURIIterator struct { + Event *ConditionTokensURI // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensURIIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensURI) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensURI) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensURIIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensURIIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensURI represents a URI event raised by the ConditionTokens contract. +type ConditionTokensURI struct { + Value string + Id *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterURI is a free log retrieval operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b. +// +// Solidity: event URI(string value, uint256 indexed id) +func (_ConditionTokens *ConditionTokensFilterer) FilterURI(opts *bind.FilterOpts, id []*big.Int) (*ConditionTokensURIIterator, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "URI", idRule) + if err != nil { + return nil, err + } + return &ConditionTokensURIIterator{contract: _ConditionTokens.contract, event: "URI", logs: logs, sub: sub}, nil +} + +// WatchURI is a free log subscription operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b. +// +// Solidity: event URI(string value, uint256 indexed id) +func (_ConditionTokens *ConditionTokensFilterer) WatchURI(opts *bind.WatchOpts, sink chan<- *ConditionTokensURI, id []*big.Int) (event.Subscription, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "URI", idRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensURI) + if err := _ConditionTokens.contract.UnpackLog(event, "URI", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseURI is a log parse operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b. +// +// Solidity: event URI(string value, uint256 indexed id) +func (_ConditionTokens *ConditionTokensFilterer) ParseURI(log types.Log) (*ConditionTokensURI, error) { + event := new(ConditionTokensURI) + if err := _ConditionTokens.contract.UnpackLog(event, "URI", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/provider/ethereum/contract/polymarket/contract_ctf_exchange.go b/provider/ethereum/contract/polymarket/contract_ctf_exchange.go new file mode 100644 index 00000000..5e50527c --- /dev/null +++ b/provider/ethereum/contract/polymarket/contract_ctf_exchange.go @@ -0,0 +1,3566 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polymarket + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// Order is an auto generated low-level Go binding around an user-defined struct. +type Order struct { + Salt *big.Int + Maker common.Address + Signer common.Address + Taker common.Address + TokenId *big.Int + MakerAmount *big.Int + TakerAmount *big.Int + Expiration *big.Int + Nonce *big.Int + FeeRateBps *big.Int + Side uint8 + SignatureType uint8 + Signature []byte +} + +// OrderStatus is an auto generated low-level Go binding around an user-defined struct. +type OrderStatus struct { + IsFilledOrCancelled bool + Remaining *big.Int +} + +// CTFExchangeMetaData contains all meta data concerning the CTFExchange contract. +var CTFExchangeMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_ctf\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_proxyFactory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_safeFactory\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FeeTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidComplement\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenId\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MakingGtRemaining\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MismatchedTokenIds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCrossing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOperator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderFilledOrCancelled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLittleTokensReceived\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"FeeCharged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newAdminAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOperatorAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderCancelled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"OrderFilled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"takerOrderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"takerOrderMaker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"}],\"name\":\"OrdersMatched\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldProxyFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProxyFactory\",\"type\":\"address\"}],\"name\":\"ProxyFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedAdmin\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedOperator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldSafeFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newSafeFactory\",\"type\":\"address\"}],\"name\":\"SafeFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token0\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"TokenRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingUnpaused\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"name\":\"addAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator_\",\"type\":\"address\"}],\"name\":\"addOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"admins\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"cancelOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"cancelOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"domainSeparator\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"fillAmount\",\"type\":\"uint256\"}],\"name\":\"fillOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"fillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"fillOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateral\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getComplement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCtf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getMaxFeeRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"getOrderStatus\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"internalType\":\"structOrderStatus\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPolyProxyFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getPolyProxyWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getProxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getSafeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isAdmin\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"isValidNonce\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"takerOrder\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"makerOrders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"takerFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"makerFillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"matchOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"operators\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"orderStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parentCollectionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"registerToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"removeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"removeOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOperatorRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"safeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProxyFactory\",\"type\":\"address\"}],\"name\":\"setProxyFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newSafeFactory\",\"type\":\"address\"}],\"name\":\"setSafeFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"}],\"name\":\"validateComplement\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrder\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrderSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"validateTokenId\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// CTFExchangeABI is the input ABI used to generate the binding from. +// Deprecated: Use CTFExchangeMetaData.ABI instead. +var CTFExchangeABI = CTFExchangeMetaData.ABI + +// CTFExchange is an auto generated Go binding around an Ethereum contract. +type CTFExchange struct { + CTFExchangeCaller // Read-only binding to the contract + CTFExchangeTransactor // Write-only binding to the contract + CTFExchangeFilterer // Log filterer for contract events +} + +// CTFExchangeCaller is an auto generated read-only Go binding around an Ethereum contract. +type CTFExchangeCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// CTFExchangeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type CTFExchangeTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// CTFExchangeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type CTFExchangeFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// CTFExchangeSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type CTFExchangeSession struct { + Contract *CTFExchange // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// CTFExchangeCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type CTFExchangeCallerSession struct { + Contract *CTFExchangeCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// CTFExchangeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type CTFExchangeTransactorSession struct { + Contract *CTFExchangeTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// CTFExchangeRaw is an auto generated low-level Go binding around an Ethereum contract. +type CTFExchangeRaw struct { + Contract *CTFExchange // Generic contract binding to access the raw methods on +} + +// CTFExchangeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type CTFExchangeCallerRaw struct { + Contract *CTFExchangeCaller // Generic read-only contract binding to access the raw methods on +} + +// CTFExchangeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type CTFExchangeTransactorRaw struct { + Contract *CTFExchangeTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewCTFExchange creates a new instance of CTFExchange, bound to a specific deployed contract. +func NewCTFExchange(address common.Address, backend bind.ContractBackend) (*CTFExchange, error) { + contract, err := bindCTFExchange(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &CTFExchange{CTFExchangeCaller: CTFExchangeCaller{contract: contract}, CTFExchangeTransactor: CTFExchangeTransactor{contract: contract}, CTFExchangeFilterer: CTFExchangeFilterer{contract: contract}}, nil +} + +// NewCTFExchangeCaller creates a new read-only instance of CTFExchange, bound to a specific deployed contract. +func NewCTFExchangeCaller(address common.Address, caller bind.ContractCaller) (*CTFExchangeCaller, error) { + contract, err := bindCTFExchange(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &CTFExchangeCaller{contract: contract}, nil +} + +// NewCTFExchangeTransactor creates a new write-only instance of CTFExchange, bound to a specific deployed contract. +func NewCTFExchangeTransactor(address common.Address, transactor bind.ContractTransactor) (*CTFExchangeTransactor, error) { + contract, err := bindCTFExchange(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &CTFExchangeTransactor{contract: contract}, nil +} + +// NewCTFExchangeFilterer creates a new log filterer instance of CTFExchange, bound to a specific deployed contract. +func NewCTFExchangeFilterer(address common.Address, filterer bind.ContractFilterer) (*CTFExchangeFilterer, error) { + contract, err := bindCTFExchange(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &CTFExchangeFilterer{contract: contract}, nil +} + +// bindCTFExchange binds a generic wrapper to an already deployed contract. +func bindCTFExchange(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := CTFExchangeMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_CTFExchange *CTFExchangeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _CTFExchange.Contract.CTFExchangeCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_CTFExchange *CTFExchangeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.Contract.CTFExchangeTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_CTFExchange *CTFExchangeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _CTFExchange.Contract.CTFExchangeTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_CTFExchange *CTFExchangeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _CTFExchange.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_CTFExchange *CTFExchangeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_CTFExchange *CTFExchangeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _CTFExchange.Contract.contract.Transact(opts, method, params...) +} + +// Admins is a free data retrieval call binding the contract method 0x429b62e5. +// +// Solidity: function admins(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCaller) Admins(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "admins", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Admins is a free data retrieval call binding the contract method 0x429b62e5. +// +// Solidity: function admins(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeSession) Admins(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Admins(&_CTFExchange.CallOpts, arg0) +} + +// Admins is a free data retrieval call binding the contract method 0x429b62e5. +// +// Solidity: function admins(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) Admins(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Admins(&_CTFExchange.CallOpts, arg0) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_CTFExchange *CTFExchangeCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "domainSeparator") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_CTFExchange *CTFExchangeSession) DomainSeparator() ([32]byte, error) { + return _CTFExchange.Contract.DomainSeparator(&_CTFExchange.CallOpts) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_CTFExchange *CTFExchangeCallerSession) DomainSeparator() ([32]byte, error) { + return _CTFExchange.Contract.DomainSeparator(&_CTFExchange.CallOpts) +} + +// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. +// +// Solidity: function getCollateral() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetCollateral(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getCollateral") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. +// +// Solidity: function getCollateral() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetCollateral() (common.Address, error) { + return _CTFExchange.Contract.GetCollateral(&_CTFExchange.CallOpts) +} + +// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. +// +// Solidity: function getCollateral() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetCollateral() (common.Address, error) { + return _CTFExchange.Contract.GetCollateral(&_CTFExchange.CallOpts) +} + +// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. +// +// Solidity: function getComplement(uint256 token) view returns(uint256) +func (_CTFExchange *CTFExchangeCaller) GetComplement(opts *bind.CallOpts, token *big.Int) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getComplement", token) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. +// +// Solidity: function getComplement(uint256 token) view returns(uint256) +func (_CTFExchange *CTFExchangeSession) GetComplement(token *big.Int) (*big.Int, error) { + return _CTFExchange.Contract.GetComplement(&_CTFExchange.CallOpts, token) +} + +// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. +// +// Solidity: function getComplement(uint256 token) view returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) GetComplement(token *big.Int) (*big.Int, error) { + return _CTFExchange.Contract.GetComplement(&_CTFExchange.CallOpts, token) +} + +// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. +// +// Solidity: function getConditionId(uint256 token) view returns(bytes32) +func (_CTFExchange *CTFExchangeCaller) GetConditionId(opts *bind.CallOpts, token *big.Int) ([32]byte, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getConditionId", token) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. +// +// Solidity: function getConditionId(uint256 token) view returns(bytes32) +func (_CTFExchange *CTFExchangeSession) GetConditionId(token *big.Int) ([32]byte, error) { + return _CTFExchange.Contract.GetConditionId(&_CTFExchange.CallOpts, token) +} + +// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. +// +// Solidity: function getConditionId(uint256 token) view returns(bytes32) +func (_CTFExchange *CTFExchangeCallerSession) GetConditionId(token *big.Int) ([32]byte, error) { + return _CTFExchange.Contract.GetConditionId(&_CTFExchange.CallOpts, token) +} + +// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. +// +// Solidity: function getCtf() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetCtf(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getCtf") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. +// +// Solidity: function getCtf() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetCtf() (common.Address, error) { + return _CTFExchange.Contract.GetCtf(&_CTFExchange.CallOpts) +} + +// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. +// +// Solidity: function getCtf() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetCtf() (common.Address, error) { + return _CTFExchange.Contract.GetCtf(&_CTFExchange.CallOpts) +} + +// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. +// +// Solidity: function getMaxFeeRate() pure returns(uint256) +func (_CTFExchange *CTFExchangeCaller) GetMaxFeeRate(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getMaxFeeRate") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. +// +// Solidity: function getMaxFeeRate() pure returns(uint256) +func (_CTFExchange *CTFExchangeSession) GetMaxFeeRate() (*big.Int, error) { + return _CTFExchange.Contract.GetMaxFeeRate(&_CTFExchange.CallOpts) +} + +// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. +// +// Solidity: function getMaxFeeRate() pure returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) GetMaxFeeRate() (*big.Int, error) { + return _CTFExchange.Contract.GetMaxFeeRate(&_CTFExchange.CallOpts) +} + +// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. +// +// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) +func (_CTFExchange *CTFExchangeCaller) GetOrderStatus(opts *bind.CallOpts, orderHash [32]byte) (OrderStatus, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getOrderStatus", orderHash) + + if err != nil { + return *new(OrderStatus), err + } + + out0 := *abi.ConvertType(out[0], new(OrderStatus)).(*OrderStatus) + + return out0, err + +} + +// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. +// +// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) +func (_CTFExchange *CTFExchangeSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { + return _CTFExchange.Contract.GetOrderStatus(&_CTFExchange.CallOpts, orderHash) +} + +// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. +// +// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) +func (_CTFExchange *CTFExchangeCallerSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { + return _CTFExchange.Contract.GetOrderStatus(&_CTFExchange.CallOpts, orderHash) +} + +// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. +// +// Solidity: function getPolyProxyFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetPolyProxyFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getPolyProxyFactoryImplementation") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. +// +// Solidity: function getPolyProxyFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetPolyProxyFactoryImplementation() (common.Address, error) { + return _CTFExchange.Contract.GetPolyProxyFactoryImplementation(&_CTFExchange.CallOpts) +} + +// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. +// +// Solidity: function getPolyProxyFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetPolyProxyFactoryImplementation() (common.Address, error) { + return _CTFExchange.Contract.GetPolyProxyFactoryImplementation(&_CTFExchange.CallOpts) +} + +// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. +// +// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetPolyProxyWalletAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getPolyProxyWalletAddress", _addr) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. +// +// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { + return _CTFExchange.Contract.GetPolyProxyWalletAddress(&_CTFExchange.CallOpts, _addr) +} + +// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. +// +// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { + return _CTFExchange.Contract.GetPolyProxyWalletAddress(&_CTFExchange.CallOpts, _addr) +} + +// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. +// +// Solidity: function getProxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetProxyFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getProxyFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. +// +// Solidity: function getProxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetProxyFactory() (common.Address, error) { + return _CTFExchange.Contract.GetProxyFactory(&_CTFExchange.CallOpts) +} + +// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. +// +// Solidity: function getProxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetProxyFactory() (common.Address, error) { + return _CTFExchange.Contract.GetProxyFactory(&_CTFExchange.CallOpts) +} + +// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. +// +// Solidity: function getSafeAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetSafeAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getSafeAddress", _addr) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. +// +// Solidity: function getSafeAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeSession) GetSafeAddress(_addr common.Address) (common.Address, error) { + return _CTFExchange.Contract.GetSafeAddress(&_CTFExchange.CallOpts, _addr) +} + +// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. +// +// Solidity: function getSafeAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetSafeAddress(_addr common.Address) (common.Address, error) { + return _CTFExchange.Contract.GetSafeAddress(&_CTFExchange.CallOpts, _addr) +} + +// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. +// +// Solidity: function getSafeFactory() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetSafeFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getSafeFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. +// +// Solidity: function getSafeFactory() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetSafeFactory() (common.Address, error) { + return _CTFExchange.Contract.GetSafeFactory(&_CTFExchange.CallOpts) +} + +// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. +// +// Solidity: function getSafeFactory() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetSafeFactory() (common.Address, error) { + return _CTFExchange.Contract.GetSafeFactory(&_CTFExchange.CallOpts) +} + +// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. +// +// Solidity: function getSafeFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetSafeFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getSafeFactoryImplementation") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. +// +// Solidity: function getSafeFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetSafeFactoryImplementation() (common.Address, error) { + return _CTFExchange.Contract.GetSafeFactoryImplementation(&_CTFExchange.CallOpts) +} + +// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. +// +// Solidity: function getSafeFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetSafeFactoryImplementation() (common.Address, error) { + return _CTFExchange.Contract.GetSafeFactoryImplementation(&_CTFExchange.CallOpts) +} + +// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. +// +// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) +func (_CTFExchange *CTFExchangeCaller) HashOrder(opts *bind.CallOpts, order Order) ([32]byte, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "hashOrder", order) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. +// +// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) +func (_CTFExchange *CTFExchangeSession) HashOrder(order Order) ([32]byte, error) { + return _CTFExchange.Contract.HashOrder(&_CTFExchange.CallOpts, order) +} + +// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. +// +// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) +func (_CTFExchange *CTFExchangeCallerSession) HashOrder(order Order) ([32]byte, error) { + return _CTFExchange.Contract.HashOrder(&_CTFExchange.CallOpts, order) +} + +// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. +// +// Solidity: function isAdmin(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeCaller) IsAdmin(opts *bind.CallOpts, usr common.Address) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "isAdmin", usr) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. +// +// Solidity: function isAdmin(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeSession) IsAdmin(usr common.Address) (bool, error) { + return _CTFExchange.Contract.IsAdmin(&_CTFExchange.CallOpts, usr) +} + +// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. +// +// Solidity: function isAdmin(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) IsAdmin(usr common.Address) (bool, error) { + return _CTFExchange.Contract.IsAdmin(&_CTFExchange.CallOpts, usr) +} + +// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. +// +// Solidity: function isOperator(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeCaller) IsOperator(opts *bind.CallOpts, usr common.Address) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "isOperator", usr) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. +// +// Solidity: function isOperator(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeSession) IsOperator(usr common.Address) (bool, error) { + return _CTFExchange.Contract.IsOperator(&_CTFExchange.CallOpts, usr) +} + +// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. +// +// Solidity: function isOperator(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) IsOperator(usr common.Address) (bool, error) { + return _CTFExchange.Contract.IsOperator(&_CTFExchange.CallOpts, usr) +} + +// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. +// +// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) +func (_CTFExchange *CTFExchangeCaller) IsValidNonce(opts *bind.CallOpts, usr common.Address, nonce *big.Int) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "isValidNonce", usr, nonce) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. +// +// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) +func (_CTFExchange *CTFExchangeSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { + return _CTFExchange.Contract.IsValidNonce(&_CTFExchange.CallOpts, usr, nonce) +} + +// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. +// +// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { + return _CTFExchange.Contract.IsValidNonce(&_CTFExchange.CallOpts, usr, nonce) +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "nonces", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeSession) Nonces(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Nonces(&_CTFExchange.CallOpts, arg0) +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) Nonces(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Nonces(&_CTFExchange.CallOpts, arg0) +} + +// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. +// +// Solidity: function operators(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCaller) Operators(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "operators", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. +// +// Solidity: function operators(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeSession) Operators(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Operators(&_CTFExchange.CallOpts, arg0) +} + +// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. +// +// Solidity: function operators(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) Operators(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Operators(&_CTFExchange.CallOpts, arg0) +} + +// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. +// +// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) +func (_CTFExchange *CTFExchangeCaller) OrderStatus(opts *bind.CallOpts, arg0 [32]byte) (struct { + IsFilledOrCancelled bool + Remaining *big.Int +}, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "orderStatus", arg0) + + outstruct := new(struct { + IsFilledOrCancelled bool + Remaining *big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.IsFilledOrCancelled = *abi.ConvertType(out[0], new(bool)).(*bool) + outstruct.Remaining = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. +// +// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) +func (_CTFExchange *CTFExchangeSession) OrderStatus(arg0 [32]byte) (struct { + IsFilledOrCancelled bool + Remaining *big.Int +}, error) { + return _CTFExchange.Contract.OrderStatus(&_CTFExchange.CallOpts, arg0) +} + +// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. +// +// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) +func (_CTFExchange *CTFExchangeCallerSession) OrderStatus(arg0 [32]byte) (struct { + IsFilledOrCancelled bool + Remaining *big.Int +}, error) { + return _CTFExchange.Contract.OrderStatus(&_CTFExchange.CallOpts, arg0) +} + +// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. +// +// Solidity: function parentCollectionId() view returns(bytes32) +func (_CTFExchange *CTFExchangeCaller) ParentCollectionId(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "parentCollectionId") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. +// +// Solidity: function parentCollectionId() view returns(bytes32) +func (_CTFExchange *CTFExchangeSession) ParentCollectionId() ([32]byte, error) { + return _CTFExchange.Contract.ParentCollectionId(&_CTFExchange.CallOpts) +} + +// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. +// +// Solidity: function parentCollectionId() view returns(bytes32) +func (_CTFExchange *CTFExchangeCallerSession) ParentCollectionId() ([32]byte, error) { + return _CTFExchange.Contract.ParentCollectionId(&_CTFExchange.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_CTFExchange *CTFExchangeCaller) Paused(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "paused") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_CTFExchange *CTFExchangeSession) Paused() (bool, error) { + return _CTFExchange.Contract.Paused(&_CTFExchange.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) Paused() (bool, error) { + return _CTFExchange.Contract.Paused(&_CTFExchange.CallOpts) +} + +// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. +// +// Solidity: function proxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeCaller) ProxyFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "proxyFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. +// +// Solidity: function proxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeSession) ProxyFactory() (common.Address, error) { + return _CTFExchange.Contract.ProxyFactory(&_CTFExchange.CallOpts) +} + +// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. +// +// Solidity: function proxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) ProxyFactory() (common.Address, error) { + return _CTFExchange.Contract.ProxyFactory(&_CTFExchange.CallOpts) +} + +// Registry is a free data retrieval call binding the contract method 0x5893253c. +// +// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) +func (_CTFExchange *CTFExchangeCaller) Registry(opts *bind.CallOpts, arg0 *big.Int) (struct { + Complement *big.Int + ConditionId [32]byte +}, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "registry", arg0) + + outstruct := new(struct { + Complement *big.Int + ConditionId [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.Complement = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.ConditionId = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// Registry is a free data retrieval call binding the contract method 0x5893253c. +// +// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) +func (_CTFExchange *CTFExchangeSession) Registry(arg0 *big.Int) (struct { + Complement *big.Int + ConditionId [32]byte +}, error) { + return _CTFExchange.Contract.Registry(&_CTFExchange.CallOpts, arg0) +} + +// Registry is a free data retrieval call binding the contract method 0x5893253c. +// +// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) +func (_CTFExchange *CTFExchangeCallerSession) Registry(arg0 *big.Int) (struct { + Complement *big.Int + ConditionId [32]byte +}, error) { + return _CTFExchange.Contract.Registry(&_CTFExchange.CallOpts, arg0) +} + +// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. +// +// Solidity: function safeFactory() view returns(address) +func (_CTFExchange *CTFExchangeCaller) SafeFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "safeFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. +// +// Solidity: function safeFactory() view returns(address) +func (_CTFExchange *CTFExchangeSession) SafeFactory() (common.Address, error) { + return _CTFExchange.Contract.SafeFactory(&_CTFExchange.CallOpts) +} + +// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. +// +// Solidity: function safeFactory() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) SafeFactory() (common.Address, error) { + return _CTFExchange.Contract.SafeFactory(&_CTFExchange.CallOpts) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_CTFExchange *CTFExchangeCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "supportsInterface", interfaceId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_CTFExchange *CTFExchangeSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _CTFExchange.Contract.SupportsInterface(&_CTFExchange.CallOpts, interfaceId) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _CTFExchange.Contract.SupportsInterface(&_CTFExchange.CallOpts, interfaceId) +} + +// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. +// +// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() +func (_CTFExchange *CTFExchangeCaller) ValidateComplement(opts *bind.CallOpts, token *big.Int, complement *big.Int) error { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "validateComplement", token, complement) + + if err != nil { + return err + } + + return err + +} + +// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. +// +// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() +func (_CTFExchange *CTFExchangeSession) ValidateComplement(token *big.Int, complement *big.Int) error { + return _CTFExchange.Contract.ValidateComplement(&_CTFExchange.CallOpts, token, complement) +} + +// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. +// +// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() +func (_CTFExchange *CTFExchangeCallerSession) ValidateComplement(token *big.Int, complement *big.Int) error { + return _CTFExchange.Contract.ValidateComplement(&_CTFExchange.CallOpts, token, complement) +} + +// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. +// +// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeCaller) ValidateOrder(opts *bind.CallOpts, order Order) error { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "validateOrder", order) + + if err != nil { + return err + } + + return err + +} + +// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. +// +// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeSession) ValidateOrder(order Order) error { + return _CTFExchange.Contract.ValidateOrder(&_CTFExchange.CallOpts, order) +} + +// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. +// +// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeCallerSession) ValidateOrder(order Order) error { + return _CTFExchange.Contract.ValidateOrder(&_CTFExchange.CallOpts, order) +} + +// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. +// +// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeCaller) ValidateOrderSignature(opts *bind.CallOpts, orderHash [32]byte, order Order) error { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "validateOrderSignature", orderHash, order) + + if err != nil { + return err + } + + return err + +} + +// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. +// +// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { + return _CTFExchange.Contract.ValidateOrderSignature(&_CTFExchange.CallOpts, orderHash, order) +} + +// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. +// +// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeCallerSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { + return _CTFExchange.Contract.ValidateOrderSignature(&_CTFExchange.CallOpts, orderHash, order) +} + +// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. +// +// Solidity: function validateTokenId(uint256 tokenId) view returns() +func (_CTFExchange *CTFExchangeCaller) ValidateTokenId(opts *bind.CallOpts, tokenId *big.Int) error { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "validateTokenId", tokenId) + + if err != nil { + return err + } + + return err + +} + +// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. +// +// Solidity: function validateTokenId(uint256 tokenId) view returns() +func (_CTFExchange *CTFExchangeSession) ValidateTokenId(tokenId *big.Int) error { + return _CTFExchange.Contract.ValidateTokenId(&_CTFExchange.CallOpts, tokenId) +} + +// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. +// +// Solidity: function validateTokenId(uint256 tokenId) view returns() +func (_CTFExchange *CTFExchangeCallerSession) ValidateTokenId(tokenId *big.Int) error { + return _CTFExchange.Contract.ValidateTokenId(&_CTFExchange.CallOpts, tokenId) +} + +// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. +// +// Solidity: function addAdmin(address admin_) returns() +func (_CTFExchange *CTFExchangeTransactor) AddAdmin(opts *bind.TransactOpts, admin_ common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "addAdmin", admin_) +} + +// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. +// +// Solidity: function addAdmin(address admin_) returns() +func (_CTFExchange *CTFExchangeSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.AddAdmin(&_CTFExchange.TransactOpts, admin_) +} + +// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. +// +// Solidity: function addAdmin(address admin_) returns() +func (_CTFExchange *CTFExchangeTransactorSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.AddAdmin(&_CTFExchange.TransactOpts, admin_) +} + +// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. +// +// Solidity: function addOperator(address operator_) returns() +func (_CTFExchange *CTFExchangeTransactor) AddOperator(opts *bind.TransactOpts, operator_ common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "addOperator", operator_) +} + +// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. +// +// Solidity: function addOperator(address operator_) returns() +func (_CTFExchange *CTFExchangeSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.AddOperator(&_CTFExchange.TransactOpts, operator_) +} + +// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. +// +// Solidity: function addOperator(address operator_) returns() +func (_CTFExchange *CTFExchangeTransactorSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.AddOperator(&_CTFExchange.TransactOpts, operator_) +} + +// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. +// +// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() +func (_CTFExchange *CTFExchangeTransactor) CancelOrder(opts *bind.TransactOpts, order Order) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "cancelOrder", order) +} + +// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. +// +// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() +func (_CTFExchange *CTFExchangeSession) CancelOrder(order Order) (*types.Transaction, error) { + return _CTFExchange.Contract.CancelOrder(&_CTFExchange.TransactOpts, order) +} + +// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. +// +// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() +func (_CTFExchange *CTFExchangeTransactorSession) CancelOrder(order Order) (*types.Transaction, error) { + return _CTFExchange.Contract.CancelOrder(&_CTFExchange.TransactOpts, order) +} + +// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. +// +// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() +func (_CTFExchange *CTFExchangeTransactor) CancelOrders(opts *bind.TransactOpts, orders []Order) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "cancelOrders", orders) +} + +// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. +// +// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() +func (_CTFExchange *CTFExchangeSession) CancelOrders(orders []Order) (*types.Transaction, error) { + return _CTFExchange.Contract.CancelOrders(&_CTFExchange.TransactOpts, orders) +} + +// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. +// +// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() +func (_CTFExchange *CTFExchangeTransactorSession) CancelOrders(orders []Order) (*types.Transaction, error) { + return _CTFExchange.Contract.CancelOrders(&_CTFExchange.TransactOpts, orders) +} + +// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. +// +// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() +func (_CTFExchange *CTFExchangeTransactor) FillOrder(opts *bind.TransactOpts, order Order, fillAmount *big.Int) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "fillOrder", order, fillAmount) +} + +// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. +// +// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() +func (_CTFExchange *CTFExchangeSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.FillOrder(&_CTFExchange.TransactOpts, order, fillAmount) +} + +// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. +// +// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() +func (_CTFExchange *CTFExchangeTransactorSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.FillOrder(&_CTFExchange.TransactOpts, order, fillAmount) +} + +// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. +// +// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() +func (_CTFExchange *CTFExchangeTransactor) FillOrders(opts *bind.TransactOpts, orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "fillOrders", orders, fillAmounts) +} + +// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. +// +// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() +func (_CTFExchange *CTFExchangeSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.FillOrders(&_CTFExchange.TransactOpts, orders, fillAmounts) +} + +// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. +// +// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() +func (_CTFExchange *CTFExchangeTransactorSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.FillOrders(&_CTFExchange.TransactOpts, orders, fillAmounts) +} + +// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. +// +// Solidity: function incrementNonce() returns() +func (_CTFExchange *CTFExchangeTransactor) IncrementNonce(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "incrementNonce") +} + +// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. +// +// Solidity: function incrementNonce() returns() +func (_CTFExchange *CTFExchangeSession) IncrementNonce() (*types.Transaction, error) { + return _CTFExchange.Contract.IncrementNonce(&_CTFExchange.TransactOpts) +} + +// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. +// +// Solidity: function incrementNonce() returns() +func (_CTFExchange *CTFExchangeTransactorSession) IncrementNonce() (*types.Transaction, error) { + return _CTFExchange.Contract.IncrementNonce(&_CTFExchange.TransactOpts) +} + +// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. +// +// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() +func (_CTFExchange *CTFExchangeTransactor) MatchOrders(opts *bind.TransactOpts, takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "matchOrders", takerOrder, makerOrders, takerFillAmount, makerFillAmounts) +} + +// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. +// +// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() +func (_CTFExchange *CTFExchangeSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.MatchOrders(&_CTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) +} + +// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. +// +// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() +func (_CTFExchange *CTFExchangeTransactorSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.MatchOrders(&_CTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) +} + +// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. +// +// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeTransactor) OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "onERC1155BatchReceived", arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. +// +// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.Contract.OnERC1155BatchReceived(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. +// +// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeTransactorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.Contract.OnERC1155BatchReceived(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. +// +// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeTransactor) OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "onERC1155Received", arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. +// +// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.Contract.OnERC1155Received(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. +// +// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeTransactorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.Contract.OnERC1155Received(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. +// +// Solidity: function pauseTrading() returns() +func (_CTFExchange *CTFExchangeTransactor) PauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "pauseTrading") +} + +// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. +// +// Solidity: function pauseTrading() returns() +func (_CTFExchange *CTFExchangeSession) PauseTrading() (*types.Transaction, error) { + return _CTFExchange.Contract.PauseTrading(&_CTFExchange.TransactOpts) +} + +// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. +// +// Solidity: function pauseTrading() returns() +func (_CTFExchange *CTFExchangeTransactorSession) PauseTrading() (*types.Transaction, error) { + return _CTFExchange.Contract.PauseTrading(&_CTFExchange.TransactOpts) +} + +// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. +// +// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() +func (_CTFExchange *CTFExchangeTransactor) RegisterToken(opts *bind.TransactOpts, token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "registerToken", token, complement, conditionId) +} + +// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. +// +// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() +func (_CTFExchange *CTFExchangeSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { + return _CTFExchange.Contract.RegisterToken(&_CTFExchange.TransactOpts, token, complement, conditionId) +} + +// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. +// +// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() +func (_CTFExchange *CTFExchangeTransactorSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { + return _CTFExchange.Contract.RegisterToken(&_CTFExchange.TransactOpts, token, complement, conditionId) +} + +// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. +// +// Solidity: function removeAdmin(address admin) returns() +func (_CTFExchange *CTFExchangeTransactor) RemoveAdmin(opts *bind.TransactOpts, admin common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "removeAdmin", admin) +} + +// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. +// +// Solidity: function removeAdmin(address admin) returns() +func (_CTFExchange *CTFExchangeSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.RemoveAdmin(&_CTFExchange.TransactOpts, admin) +} + +// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. +// +// Solidity: function removeAdmin(address admin) returns() +func (_CTFExchange *CTFExchangeTransactorSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.RemoveAdmin(&_CTFExchange.TransactOpts, admin) +} + +// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. +// +// Solidity: function removeOperator(address operator) returns() +func (_CTFExchange *CTFExchangeTransactor) RemoveOperator(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "removeOperator", operator) +} + +// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. +// +// Solidity: function removeOperator(address operator) returns() +func (_CTFExchange *CTFExchangeSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.RemoveOperator(&_CTFExchange.TransactOpts, operator) +} + +// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. +// +// Solidity: function removeOperator(address operator) returns() +func (_CTFExchange *CTFExchangeTransactorSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.RemoveOperator(&_CTFExchange.TransactOpts, operator) +} + +// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. +// +// Solidity: function renounceAdminRole() returns() +func (_CTFExchange *CTFExchangeTransactor) RenounceAdminRole(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "renounceAdminRole") +} + +// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. +// +// Solidity: function renounceAdminRole() returns() +func (_CTFExchange *CTFExchangeSession) RenounceAdminRole() (*types.Transaction, error) { + return _CTFExchange.Contract.RenounceAdminRole(&_CTFExchange.TransactOpts) +} + +// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. +// +// Solidity: function renounceAdminRole() returns() +func (_CTFExchange *CTFExchangeTransactorSession) RenounceAdminRole() (*types.Transaction, error) { + return _CTFExchange.Contract.RenounceAdminRole(&_CTFExchange.TransactOpts) +} + +// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. +// +// Solidity: function renounceOperatorRole() returns() +func (_CTFExchange *CTFExchangeTransactor) RenounceOperatorRole(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "renounceOperatorRole") +} + +// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. +// +// Solidity: function renounceOperatorRole() returns() +func (_CTFExchange *CTFExchangeSession) RenounceOperatorRole() (*types.Transaction, error) { + return _CTFExchange.Contract.RenounceOperatorRole(&_CTFExchange.TransactOpts) +} + +// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. +// +// Solidity: function renounceOperatorRole() returns() +func (_CTFExchange *CTFExchangeTransactorSession) RenounceOperatorRole() (*types.Transaction, error) { + return _CTFExchange.Contract.RenounceOperatorRole(&_CTFExchange.TransactOpts) +} + +// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. +// +// Solidity: function setProxyFactory(address _newProxyFactory) returns() +func (_CTFExchange *CTFExchangeTransactor) SetProxyFactory(opts *bind.TransactOpts, _newProxyFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "setProxyFactory", _newProxyFactory) +} + +// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. +// +// Solidity: function setProxyFactory(address _newProxyFactory) returns() +func (_CTFExchange *CTFExchangeSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.SetProxyFactory(&_CTFExchange.TransactOpts, _newProxyFactory) +} + +// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. +// +// Solidity: function setProxyFactory(address _newProxyFactory) returns() +func (_CTFExchange *CTFExchangeTransactorSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.SetProxyFactory(&_CTFExchange.TransactOpts, _newProxyFactory) +} + +// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. +// +// Solidity: function setSafeFactory(address _newSafeFactory) returns() +func (_CTFExchange *CTFExchangeTransactor) SetSafeFactory(opts *bind.TransactOpts, _newSafeFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "setSafeFactory", _newSafeFactory) +} + +// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. +// +// Solidity: function setSafeFactory(address _newSafeFactory) returns() +func (_CTFExchange *CTFExchangeSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.SetSafeFactory(&_CTFExchange.TransactOpts, _newSafeFactory) +} + +// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. +// +// Solidity: function setSafeFactory(address _newSafeFactory) returns() +func (_CTFExchange *CTFExchangeTransactorSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.SetSafeFactory(&_CTFExchange.TransactOpts, _newSafeFactory) +} + +// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. +// +// Solidity: function unpauseTrading() returns() +func (_CTFExchange *CTFExchangeTransactor) UnpauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "unpauseTrading") +} + +// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. +// +// Solidity: function unpauseTrading() returns() +func (_CTFExchange *CTFExchangeSession) UnpauseTrading() (*types.Transaction, error) { + return _CTFExchange.Contract.UnpauseTrading(&_CTFExchange.TransactOpts) +} + +// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. +// +// Solidity: function unpauseTrading() returns() +func (_CTFExchange *CTFExchangeTransactorSession) UnpauseTrading() (*types.Transaction, error) { + return _CTFExchange.Contract.UnpauseTrading(&_CTFExchange.TransactOpts) +} + +// CTFExchangeFeeChargedIterator is returned from FilterFeeCharged and is used to iterate over the raw logs and unpacked data for FeeCharged events raised by the CTFExchange contract. +type CTFExchangeFeeChargedIterator struct { + Event *CTFExchangeFeeCharged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeFeeChargedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeFeeCharged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeFeeCharged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeFeeChargedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeFeeChargedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeFeeCharged represents a FeeCharged event raised by the CTFExchange contract. +type CTFExchangeFeeCharged struct { + Receiver common.Address + TokenId *big.Int + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterFeeCharged is a free log retrieval operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. +// +// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) +func (_CTFExchange *CTFExchangeFilterer) FilterFeeCharged(opts *bind.FilterOpts, receiver []common.Address) (*CTFExchangeFeeChargedIterator, error) { + + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "FeeCharged", receiverRule) + if err != nil { + return nil, err + } + return &CTFExchangeFeeChargedIterator{contract: _CTFExchange.contract, event: "FeeCharged", logs: logs, sub: sub}, nil +} + +// WatchFeeCharged is a free log subscription operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. +// +// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) +func (_CTFExchange *CTFExchangeFilterer) WatchFeeCharged(opts *bind.WatchOpts, sink chan<- *CTFExchangeFeeCharged, receiver []common.Address) (event.Subscription, error) { + + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "FeeCharged", receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeFeeCharged) + if err := _CTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseFeeCharged is a log parse operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. +// +// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) +func (_CTFExchange *CTFExchangeFilterer) ParseFeeCharged(log types.Log) (*CTFExchangeFeeCharged, error) { + event := new(CTFExchangeFeeCharged) + if err := _CTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeNewAdminIterator is returned from FilterNewAdmin and is used to iterate over the raw logs and unpacked data for NewAdmin events raised by the CTFExchange contract. +type CTFExchangeNewAdminIterator struct { + Event *CTFExchangeNewAdmin // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeNewAdminIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeNewAdminIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeNewAdminIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeNewAdmin represents a NewAdmin event raised by the CTFExchange contract. +type CTFExchangeNewAdmin struct { + NewAdminAddress common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewAdmin is a free log retrieval operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. +// +// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) FilterNewAdmin(opts *bind.FilterOpts, newAdminAddress []common.Address, admin []common.Address) (*CTFExchangeNewAdminIterator, error) { + + var newAdminAddressRule []interface{} + for _, newAdminAddressItem := range newAdminAddress { + newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) + if err != nil { + return nil, err + } + return &CTFExchangeNewAdminIterator{contract: _CTFExchange.contract, event: "NewAdmin", logs: logs, sub: sub}, nil +} + +// WatchNewAdmin is a free log subscription operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. +// +// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) WatchNewAdmin(opts *bind.WatchOpts, sink chan<- *CTFExchangeNewAdmin, newAdminAddress []common.Address, admin []common.Address) (event.Subscription, error) { + + var newAdminAddressRule []interface{} + for _, newAdminAddressItem := range newAdminAddress { + newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeNewAdmin) + if err := _CTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewAdmin is a log parse operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. +// +// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) ParseNewAdmin(log types.Log) (*CTFExchangeNewAdmin, error) { + event := new(CTFExchangeNewAdmin) + if err := _CTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeNewOperatorIterator is returned from FilterNewOperator and is used to iterate over the raw logs and unpacked data for NewOperator events raised by the CTFExchange contract. +type CTFExchangeNewOperatorIterator struct { + Event *CTFExchangeNewOperator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeNewOperatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeNewOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeNewOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeNewOperatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeNewOperatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeNewOperator represents a NewOperator event raised by the CTFExchange contract. +type CTFExchangeNewOperator struct { + NewOperatorAddress common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewOperator is a free log retrieval operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. +// +// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) FilterNewOperator(opts *bind.FilterOpts, newOperatorAddress []common.Address, admin []common.Address) (*CTFExchangeNewOperatorIterator, error) { + + var newOperatorAddressRule []interface{} + for _, newOperatorAddressItem := range newOperatorAddress { + newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) + if err != nil { + return nil, err + } + return &CTFExchangeNewOperatorIterator{contract: _CTFExchange.contract, event: "NewOperator", logs: logs, sub: sub}, nil +} + +// WatchNewOperator is a free log subscription operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. +// +// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) WatchNewOperator(opts *bind.WatchOpts, sink chan<- *CTFExchangeNewOperator, newOperatorAddress []common.Address, admin []common.Address) (event.Subscription, error) { + + var newOperatorAddressRule []interface{} + for _, newOperatorAddressItem := range newOperatorAddress { + newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeNewOperator) + if err := _CTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewOperator is a log parse operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. +// +// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) ParseNewOperator(log types.Log) (*CTFExchangeNewOperator, error) { + event := new(CTFExchangeNewOperator) + if err := _CTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeOrderCancelledIterator is returned from FilterOrderCancelled and is used to iterate over the raw logs and unpacked data for OrderCancelled events raised by the CTFExchange contract. +type CTFExchangeOrderCancelledIterator struct { + Event *CTFExchangeOrderCancelled // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeOrderCancelledIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrderCancelled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrderCancelled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeOrderCancelledIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeOrderCancelledIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeOrderCancelled represents a OrderCancelled event raised by the CTFExchange contract. +type CTFExchangeOrderCancelled struct { + OrderHash [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOrderCancelled is a free log retrieval operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. +// +// Solidity: event OrderCancelled(bytes32 indexed orderHash) +func (_CTFExchange *CTFExchangeFilterer) FilterOrderCancelled(opts *bind.FilterOpts, orderHash [][32]byte) (*CTFExchangeOrderCancelledIterator, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "OrderCancelled", orderHashRule) + if err != nil { + return nil, err + } + return &CTFExchangeOrderCancelledIterator{contract: _CTFExchange.contract, event: "OrderCancelled", logs: logs, sub: sub}, nil +} + +// WatchOrderCancelled is a free log subscription operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. +// +// Solidity: event OrderCancelled(bytes32 indexed orderHash) +func (_CTFExchange *CTFExchangeFilterer) WatchOrderCancelled(opts *bind.WatchOpts, sink chan<- *CTFExchangeOrderCancelled, orderHash [][32]byte) (event.Subscription, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "OrderCancelled", orderHashRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeOrderCancelled) + if err := _CTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOrderCancelled is a log parse operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. +// +// Solidity: event OrderCancelled(bytes32 indexed orderHash) +func (_CTFExchange *CTFExchangeFilterer) ParseOrderCancelled(log types.Log) (*CTFExchangeOrderCancelled, error) { + event := new(CTFExchangeOrderCancelled) + if err := _CTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeOrderFilledIterator is returned from FilterOrderFilled and is used to iterate over the raw logs and unpacked data for OrderFilled events raised by the CTFExchange contract. +type CTFExchangeOrderFilledIterator struct { + Event *CTFExchangeOrderFilled // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeOrderFilledIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrderFilled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrderFilled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeOrderFilledIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeOrderFilledIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeOrderFilled represents a OrderFilled event raised by the CTFExchange contract. +type CTFExchangeOrderFilled struct { + OrderHash [32]byte + Maker common.Address + Taker common.Address + MakerAssetId *big.Int + TakerAssetId *big.Int + MakerAmountFilled *big.Int + TakerAmountFilled *big.Int + Fee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOrderFilled is a free log retrieval operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. +// +// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) +func (_CTFExchange *CTFExchangeFilterer) FilterOrderFilled(opts *bind.FilterOpts, orderHash [][32]byte, maker []common.Address, taker []common.Address) (*CTFExchangeOrderFilledIterator, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + var makerRule []interface{} + for _, makerItem := range maker { + makerRule = append(makerRule, makerItem) + } + var takerRule []interface{} + for _, takerItem := range taker { + takerRule = append(takerRule, takerItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) + if err != nil { + return nil, err + } + return &CTFExchangeOrderFilledIterator{contract: _CTFExchange.contract, event: "OrderFilled", logs: logs, sub: sub}, nil +} + +// WatchOrderFilled is a free log subscription operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. +// +// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) +func (_CTFExchange *CTFExchangeFilterer) WatchOrderFilled(opts *bind.WatchOpts, sink chan<- *CTFExchangeOrderFilled, orderHash [][32]byte, maker []common.Address, taker []common.Address) (event.Subscription, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + var makerRule []interface{} + for _, makerItem := range maker { + makerRule = append(makerRule, makerItem) + } + var takerRule []interface{} + for _, takerItem := range taker { + takerRule = append(takerRule, takerItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeOrderFilled) + if err := _CTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOrderFilled is a log parse operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. +// +// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) +func (_CTFExchange *CTFExchangeFilterer) ParseOrderFilled(log types.Log) (*CTFExchangeOrderFilled, error) { + event := new(CTFExchangeOrderFilled) + if err := _CTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeOrdersMatchedIterator is returned from FilterOrdersMatched and is used to iterate over the raw logs and unpacked data for OrdersMatched events raised by the CTFExchange contract. +type CTFExchangeOrdersMatchedIterator struct { + Event *CTFExchangeOrdersMatched // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeOrdersMatchedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrdersMatched) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrdersMatched) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeOrdersMatchedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeOrdersMatchedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeOrdersMatched represents a OrdersMatched event raised by the CTFExchange contract. +type CTFExchangeOrdersMatched struct { + TakerOrderHash [32]byte + TakerOrderMaker common.Address + MakerAssetId *big.Int + TakerAssetId *big.Int + MakerAmountFilled *big.Int + TakerAmountFilled *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOrdersMatched is a free log retrieval operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. +// +// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) +func (_CTFExchange *CTFExchangeFilterer) FilterOrdersMatched(opts *bind.FilterOpts, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (*CTFExchangeOrdersMatchedIterator, error) { + + var takerOrderHashRule []interface{} + for _, takerOrderHashItem := range takerOrderHash { + takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) + } + var takerOrderMakerRule []interface{} + for _, takerOrderMakerItem := range takerOrderMaker { + takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) + if err != nil { + return nil, err + } + return &CTFExchangeOrdersMatchedIterator{contract: _CTFExchange.contract, event: "OrdersMatched", logs: logs, sub: sub}, nil +} + +// WatchOrdersMatched is a free log subscription operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. +// +// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) +func (_CTFExchange *CTFExchangeFilterer) WatchOrdersMatched(opts *bind.WatchOpts, sink chan<- *CTFExchangeOrdersMatched, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (event.Subscription, error) { + + var takerOrderHashRule []interface{} + for _, takerOrderHashItem := range takerOrderHash { + takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) + } + var takerOrderMakerRule []interface{} + for _, takerOrderMakerItem := range takerOrderMaker { + takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeOrdersMatched) + if err := _CTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOrdersMatched is a log parse operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. +// +// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) +func (_CTFExchange *CTFExchangeFilterer) ParseOrdersMatched(log types.Log) (*CTFExchangeOrdersMatched, error) { + event := new(CTFExchangeOrdersMatched) + if err := _CTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeProxyFactoryUpdatedIterator is returned from FilterProxyFactoryUpdated and is used to iterate over the raw logs and unpacked data for ProxyFactoryUpdated events raised by the CTFExchange contract. +type CTFExchangeProxyFactoryUpdatedIterator struct { + Event *CTFExchangeProxyFactoryUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeProxyFactoryUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeProxyFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeProxyFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeProxyFactoryUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeProxyFactoryUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeProxyFactoryUpdated represents a ProxyFactoryUpdated event raised by the CTFExchange contract. +type CTFExchangeProxyFactoryUpdated struct { + OldProxyFactory common.Address + NewProxyFactory common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterProxyFactoryUpdated is a free log retrieval operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. +// +// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) +func (_CTFExchange *CTFExchangeFilterer) FilterProxyFactoryUpdated(opts *bind.FilterOpts, oldProxyFactory []common.Address, newProxyFactory []common.Address) (*CTFExchangeProxyFactoryUpdatedIterator, error) { + + var oldProxyFactoryRule []interface{} + for _, oldProxyFactoryItem := range oldProxyFactory { + oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) + } + var newProxyFactoryRule []interface{} + for _, newProxyFactoryItem := range newProxyFactory { + newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) + if err != nil { + return nil, err + } + return &CTFExchangeProxyFactoryUpdatedIterator{contract: _CTFExchange.contract, event: "ProxyFactoryUpdated", logs: logs, sub: sub}, nil +} + +// WatchProxyFactoryUpdated is a free log subscription operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. +// +// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) +func (_CTFExchange *CTFExchangeFilterer) WatchProxyFactoryUpdated(opts *bind.WatchOpts, sink chan<- *CTFExchangeProxyFactoryUpdated, oldProxyFactory []common.Address, newProxyFactory []common.Address) (event.Subscription, error) { + + var oldProxyFactoryRule []interface{} + for _, oldProxyFactoryItem := range oldProxyFactory { + oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) + } + var newProxyFactoryRule []interface{} + for _, newProxyFactoryItem := range newProxyFactory { + newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeProxyFactoryUpdated) + if err := _CTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseProxyFactoryUpdated is a log parse operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. +// +// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) +func (_CTFExchange *CTFExchangeFilterer) ParseProxyFactoryUpdated(log types.Log) (*CTFExchangeProxyFactoryUpdated, error) { + event := new(CTFExchangeProxyFactoryUpdated) + if err := _CTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeRemovedAdminIterator is returned from FilterRemovedAdmin and is used to iterate over the raw logs and unpacked data for RemovedAdmin events raised by the CTFExchange contract. +type CTFExchangeRemovedAdminIterator struct { + Event *CTFExchangeRemovedAdmin // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeRemovedAdminIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeRemovedAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeRemovedAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeRemovedAdminIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeRemovedAdminIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeRemovedAdmin represents a RemovedAdmin event raised by the CTFExchange contract. +type CTFExchangeRemovedAdmin struct { + RemovedAdmin common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemovedAdmin is a free log retrieval operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. +// +// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) FilterRemovedAdmin(opts *bind.FilterOpts, removedAdmin []common.Address, admin []common.Address) (*CTFExchangeRemovedAdminIterator, error) { + + var removedAdminRule []interface{} + for _, removedAdminItem := range removedAdmin { + removedAdminRule = append(removedAdminRule, removedAdminItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) + if err != nil { + return nil, err + } + return &CTFExchangeRemovedAdminIterator{contract: _CTFExchange.contract, event: "RemovedAdmin", logs: logs, sub: sub}, nil +} + +// WatchRemovedAdmin is a free log subscription operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. +// +// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) WatchRemovedAdmin(opts *bind.WatchOpts, sink chan<- *CTFExchangeRemovedAdmin, removedAdmin []common.Address, admin []common.Address) (event.Subscription, error) { + + var removedAdminRule []interface{} + for _, removedAdminItem := range removedAdmin { + removedAdminRule = append(removedAdminRule, removedAdminItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeRemovedAdmin) + if err := _CTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemovedAdmin is a log parse operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. +// +// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) ParseRemovedAdmin(log types.Log) (*CTFExchangeRemovedAdmin, error) { + event := new(CTFExchangeRemovedAdmin) + if err := _CTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeRemovedOperatorIterator is returned from FilterRemovedOperator and is used to iterate over the raw logs and unpacked data for RemovedOperator events raised by the CTFExchange contract. +type CTFExchangeRemovedOperatorIterator struct { + Event *CTFExchangeRemovedOperator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeRemovedOperatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeRemovedOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeRemovedOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeRemovedOperatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeRemovedOperatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeRemovedOperator represents a RemovedOperator event raised by the CTFExchange contract. +type CTFExchangeRemovedOperator struct { + RemovedOperator common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemovedOperator is a free log retrieval operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. +// +// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) FilterRemovedOperator(opts *bind.FilterOpts, removedOperator []common.Address, admin []common.Address) (*CTFExchangeRemovedOperatorIterator, error) { + + var removedOperatorRule []interface{} + for _, removedOperatorItem := range removedOperator { + removedOperatorRule = append(removedOperatorRule, removedOperatorItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) + if err != nil { + return nil, err + } + return &CTFExchangeRemovedOperatorIterator{contract: _CTFExchange.contract, event: "RemovedOperator", logs: logs, sub: sub}, nil +} + +// WatchRemovedOperator is a free log subscription operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. +// +// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) WatchRemovedOperator(opts *bind.WatchOpts, sink chan<- *CTFExchangeRemovedOperator, removedOperator []common.Address, admin []common.Address) (event.Subscription, error) { + + var removedOperatorRule []interface{} + for _, removedOperatorItem := range removedOperator { + removedOperatorRule = append(removedOperatorRule, removedOperatorItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeRemovedOperator) + if err := _CTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemovedOperator is a log parse operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. +// +// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) ParseRemovedOperator(log types.Log) (*CTFExchangeRemovedOperator, error) { + event := new(CTFExchangeRemovedOperator) + if err := _CTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeSafeFactoryUpdatedIterator is returned from FilterSafeFactoryUpdated and is used to iterate over the raw logs and unpacked data for SafeFactoryUpdated events raised by the CTFExchange contract. +type CTFExchangeSafeFactoryUpdatedIterator struct { + Event *CTFExchangeSafeFactoryUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeSafeFactoryUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeSafeFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeSafeFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeSafeFactoryUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeSafeFactoryUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeSafeFactoryUpdated represents a SafeFactoryUpdated event raised by the CTFExchange contract. +type CTFExchangeSafeFactoryUpdated struct { + OldSafeFactory common.Address + NewSafeFactory common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSafeFactoryUpdated is a free log retrieval operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. +// +// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) +func (_CTFExchange *CTFExchangeFilterer) FilterSafeFactoryUpdated(opts *bind.FilterOpts, oldSafeFactory []common.Address, newSafeFactory []common.Address) (*CTFExchangeSafeFactoryUpdatedIterator, error) { + + var oldSafeFactoryRule []interface{} + for _, oldSafeFactoryItem := range oldSafeFactory { + oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) + } + var newSafeFactoryRule []interface{} + for _, newSafeFactoryItem := range newSafeFactory { + newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) + if err != nil { + return nil, err + } + return &CTFExchangeSafeFactoryUpdatedIterator{contract: _CTFExchange.contract, event: "SafeFactoryUpdated", logs: logs, sub: sub}, nil +} + +// WatchSafeFactoryUpdated is a free log subscription operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. +// +// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) +func (_CTFExchange *CTFExchangeFilterer) WatchSafeFactoryUpdated(opts *bind.WatchOpts, sink chan<- *CTFExchangeSafeFactoryUpdated, oldSafeFactory []common.Address, newSafeFactory []common.Address) (event.Subscription, error) { + + var oldSafeFactoryRule []interface{} + for _, oldSafeFactoryItem := range oldSafeFactory { + oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) + } + var newSafeFactoryRule []interface{} + for _, newSafeFactoryItem := range newSafeFactory { + newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeSafeFactoryUpdated) + if err := _CTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSafeFactoryUpdated is a log parse operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. +// +// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) +func (_CTFExchange *CTFExchangeFilterer) ParseSafeFactoryUpdated(log types.Log) (*CTFExchangeSafeFactoryUpdated, error) { + event := new(CTFExchangeSafeFactoryUpdated) + if err := _CTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeTokenRegisteredIterator is returned from FilterTokenRegistered and is used to iterate over the raw logs and unpacked data for TokenRegistered events raised by the CTFExchange contract. +type CTFExchangeTokenRegisteredIterator struct { + Event *CTFExchangeTokenRegistered // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeTokenRegisteredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTokenRegistered) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTokenRegistered) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeTokenRegisteredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeTokenRegisteredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeTokenRegistered represents a TokenRegistered event raised by the CTFExchange contract. +type CTFExchangeTokenRegistered struct { + Token0 *big.Int + Token1 *big.Int + ConditionId [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTokenRegistered is a free log retrieval operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. +// +// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) +func (_CTFExchange *CTFExchangeFilterer) FilterTokenRegistered(opts *bind.FilterOpts, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (*CTFExchangeTokenRegisteredIterator, error) { + + var token0Rule []interface{} + for _, token0Item := range token0 { + token0Rule = append(token0Rule, token0Item) + } + var token1Rule []interface{} + for _, token1Item := range token1 { + token1Rule = append(token1Rule, token1Item) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) + if err != nil { + return nil, err + } + return &CTFExchangeTokenRegisteredIterator{contract: _CTFExchange.contract, event: "TokenRegistered", logs: logs, sub: sub}, nil +} + +// WatchTokenRegistered is a free log subscription operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. +// +// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) +func (_CTFExchange *CTFExchangeFilterer) WatchTokenRegistered(opts *bind.WatchOpts, sink chan<- *CTFExchangeTokenRegistered, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (event.Subscription, error) { + + var token0Rule []interface{} + for _, token0Item := range token0 { + token0Rule = append(token0Rule, token0Item) + } + var token1Rule []interface{} + for _, token1Item := range token1 { + token1Rule = append(token1Rule, token1Item) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeTokenRegistered) + if err := _CTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTokenRegistered is a log parse operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. +// +// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) +func (_CTFExchange *CTFExchangeFilterer) ParseTokenRegistered(log types.Log) (*CTFExchangeTokenRegistered, error) { + event := new(CTFExchangeTokenRegistered) + if err := _CTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeTradingPausedIterator is returned from FilterTradingPaused and is used to iterate over the raw logs and unpacked data for TradingPaused events raised by the CTFExchange contract. +type CTFExchangeTradingPausedIterator struct { + Event *CTFExchangeTradingPaused // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeTradingPausedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTradingPaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTradingPaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeTradingPausedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeTradingPausedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeTradingPaused represents a TradingPaused event raised by the CTFExchange contract. +type CTFExchangeTradingPaused struct { + Pauser common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTradingPaused is a free log retrieval operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. +// +// Solidity: event TradingPaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) FilterTradingPaused(opts *bind.FilterOpts, pauser []common.Address) (*CTFExchangeTradingPausedIterator, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "TradingPaused", pauserRule) + if err != nil { + return nil, err + } + return &CTFExchangeTradingPausedIterator{contract: _CTFExchange.contract, event: "TradingPaused", logs: logs, sub: sub}, nil +} + +// WatchTradingPaused is a free log subscription operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. +// +// Solidity: event TradingPaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) WatchTradingPaused(opts *bind.WatchOpts, sink chan<- *CTFExchangeTradingPaused, pauser []common.Address) (event.Subscription, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "TradingPaused", pauserRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeTradingPaused) + if err := _CTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTradingPaused is a log parse operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. +// +// Solidity: event TradingPaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) ParseTradingPaused(log types.Log) (*CTFExchangeTradingPaused, error) { + event := new(CTFExchangeTradingPaused) + if err := _CTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeTradingUnpausedIterator is returned from FilterTradingUnpaused and is used to iterate over the raw logs and unpacked data for TradingUnpaused events raised by the CTFExchange contract. +type CTFExchangeTradingUnpausedIterator struct { + Event *CTFExchangeTradingUnpaused // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeTradingUnpausedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTradingUnpaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTradingUnpaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeTradingUnpausedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeTradingUnpausedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeTradingUnpaused represents a TradingUnpaused event raised by the CTFExchange contract. +type CTFExchangeTradingUnpaused struct { + Pauser common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTradingUnpaused is a free log retrieval operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. +// +// Solidity: event TradingUnpaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) FilterTradingUnpaused(opts *bind.FilterOpts, pauser []common.Address) (*CTFExchangeTradingUnpausedIterator, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "TradingUnpaused", pauserRule) + if err != nil { + return nil, err + } + return &CTFExchangeTradingUnpausedIterator{contract: _CTFExchange.contract, event: "TradingUnpaused", logs: logs, sub: sub}, nil +} + +// WatchTradingUnpaused is a free log subscription operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. +// +// Solidity: event TradingUnpaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) WatchTradingUnpaused(opts *bind.WatchOpts, sink chan<- *CTFExchangeTradingUnpaused, pauser []common.Address) (event.Subscription, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "TradingUnpaused", pauserRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeTradingUnpaused) + if err := _CTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTradingUnpaused is a log parse operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. +// +// Solidity: event TradingUnpaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) ParseTradingUnpaused(log types.Log) (*CTFExchangeTradingUnpaused, error) { + event := new(CTFExchangeTradingUnpaused) + if err := _CTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go b/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go new file mode 100644 index 00000000..bd2aa0f0 --- /dev/null +++ b/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go @@ -0,0 +1,3566 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polymarket + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// Order is an auto generated low-level Go binding around an user-defined struct. +type Order struct { + Salt *big.Int + Maker common.Address + Signer common.Address + Taker common.Address + TokenId *big.Int + MakerAmount *big.Int + TakerAmount *big.Int + Expiration *big.Int + Nonce *big.Int + FeeRateBps *big.Int + Side uint8 + SignatureType uint8 + Signature []byte +} + +// OrderStatus is an auto generated low-level Go binding around an user-defined struct. +type OrderStatus struct { + IsFilledOrCancelled bool + Remaining *big.Int +} + +// NegRiskCTFExchangeMetaData contains all meta data concerning the NegRiskCTFExchange contract. +var NegRiskCTFExchangeMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_ctf\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_negRiskAdapter\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_proxyFactory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_safeFactory\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FeeTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidComplement\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenId\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MakingGtRemaining\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MismatchedTokenIds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCrossing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOperator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderFilledOrCancelled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLittleTokensReceived\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"FeeCharged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newAdminAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOperatorAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderCancelled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"OrderFilled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"takerOrderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"takerOrderMaker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"}],\"name\":\"OrdersMatched\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldProxyFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProxyFactory\",\"type\":\"address\"}],\"name\":\"ProxyFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedAdmin\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedOperator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldSafeFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newSafeFactory\",\"type\":\"address\"}],\"name\":\"SafeFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token0\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"TokenRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingUnpaused\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"name\":\"addAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator_\",\"type\":\"address\"}],\"name\":\"addOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"admins\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"cancelOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"cancelOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"domainSeparator\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"fillAmount\",\"type\":\"uint256\"}],\"name\":\"fillOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"fillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"fillOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateral\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getComplement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCtf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getMaxFeeRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"getOrderStatus\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"internalType\":\"structOrderStatus\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPolyProxyFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getPolyProxyWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getProxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getSafeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isAdmin\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"isValidNonce\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"takerOrder\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"makerOrders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"takerFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"makerFillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"matchOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"operators\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"orderStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parentCollectionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"registerToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"removeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"removeOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOperatorRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"safeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProxyFactory\",\"type\":\"address\"}],\"name\":\"setProxyFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newSafeFactory\",\"type\":\"address\"}],\"name\":\"setSafeFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"}],\"name\":\"validateComplement\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrder\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrderSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"validateTokenId\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// NegRiskCTFExchangeABI is the input ABI used to generate the binding from. +// Deprecated: Use NegRiskCTFExchangeMetaData.ABI instead. +var NegRiskCTFExchangeABI = NegRiskCTFExchangeMetaData.ABI + +// NegRiskCTFExchange is an auto generated Go binding around an Ethereum contract. +type NegRiskCTFExchange struct { + NegRiskCTFExchangeCaller // Read-only binding to the contract + NegRiskCTFExchangeTransactor // Write-only binding to the contract + NegRiskCTFExchangeFilterer // Log filterer for contract events +} + +// NegRiskCTFExchangeCaller is an auto generated read-only Go binding around an Ethereum contract. +type NegRiskCTFExchangeCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// NegRiskCTFExchangeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type NegRiskCTFExchangeTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// NegRiskCTFExchangeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type NegRiskCTFExchangeFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// NegRiskCTFExchangeSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type NegRiskCTFExchangeSession struct { + Contract *NegRiskCTFExchange // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// NegRiskCTFExchangeCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type NegRiskCTFExchangeCallerSession struct { + Contract *NegRiskCTFExchangeCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// NegRiskCTFExchangeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type NegRiskCTFExchangeTransactorSession struct { + Contract *NegRiskCTFExchangeTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// NegRiskCTFExchangeRaw is an auto generated low-level Go binding around an Ethereum contract. +type NegRiskCTFExchangeRaw struct { + Contract *NegRiskCTFExchange // Generic contract binding to access the raw methods on +} + +// NegRiskCTFExchangeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type NegRiskCTFExchangeCallerRaw struct { + Contract *NegRiskCTFExchangeCaller // Generic read-only contract binding to access the raw methods on +} + +// NegRiskCTFExchangeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type NegRiskCTFExchangeTransactorRaw struct { + Contract *NegRiskCTFExchangeTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewNegRiskCTFExchange creates a new instance of NegRiskCTFExchange, bound to a specific deployed contract. +func NewNegRiskCTFExchange(address common.Address, backend bind.ContractBackend) (*NegRiskCTFExchange, error) { + contract, err := bindNegRiskCTFExchange(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &NegRiskCTFExchange{NegRiskCTFExchangeCaller: NegRiskCTFExchangeCaller{contract: contract}, NegRiskCTFExchangeTransactor: NegRiskCTFExchangeTransactor{contract: contract}, NegRiskCTFExchangeFilterer: NegRiskCTFExchangeFilterer{contract: contract}}, nil +} + +// NewNegRiskCTFExchangeCaller creates a new read-only instance of NegRiskCTFExchange, bound to a specific deployed contract. +func NewNegRiskCTFExchangeCaller(address common.Address, caller bind.ContractCaller) (*NegRiskCTFExchangeCaller, error) { + contract, err := bindNegRiskCTFExchange(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeCaller{contract: contract}, nil +} + +// NewNegRiskCTFExchangeTransactor creates a new write-only instance of NegRiskCTFExchange, bound to a specific deployed contract. +func NewNegRiskCTFExchangeTransactor(address common.Address, transactor bind.ContractTransactor) (*NegRiskCTFExchangeTransactor, error) { + contract, err := bindNegRiskCTFExchange(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeTransactor{contract: contract}, nil +} + +// NewNegRiskCTFExchangeFilterer creates a new log filterer instance of NegRiskCTFExchange, bound to a specific deployed contract. +func NewNegRiskCTFExchangeFilterer(address common.Address, filterer bind.ContractFilterer) (*NegRiskCTFExchangeFilterer, error) { + contract, err := bindNegRiskCTFExchange(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeFilterer{contract: contract}, nil +} + +// bindNegRiskCTFExchange binds a generic wrapper to an already deployed contract. +func bindNegRiskCTFExchange(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := NegRiskCTFExchangeMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_NegRiskCTFExchange *NegRiskCTFExchangeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _NegRiskCTFExchange.Contract.NegRiskCTFExchangeCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_NegRiskCTFExchange *NegRiskCTFExchangeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.NegRiskCTFExchangeTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_NegRiskCTFExchange *NegRiskCTFExchangeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.NegRiskCTFExchangeTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _NegRiskCTFExchange.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.contract.Transact(opts, method, params...) +} + +// Admins is a free data retrieval call binding the contract method 0x429b62e5. +// +// Solidity: function admins(address ) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Admins(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "admins", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Admins is a free data retrieval call binding the contract method 0x429b62e5. +// +// Solidity: function admins(address ) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Admins(arg0 common.Address) (*big.Int, error) { + return _NegRiskCTFExchange.Contract.Admins(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// Admins is a free data retrieval call binding the contract method 0x429b62e5. +// +// Solidity: function admins(address ) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Admins(arg0 common.Address) (*big.Int, error) { + return _NegRiskCTFExchange.Contract.Admins(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "domainSeparator") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) DomainSeparator() ([32]byte, error) { + return _NegRiskCTFExchange.Contract.DomainSeparator(&_NegRiskCTFExchange.CallOpts) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) DomainSeparator() ([32]byte, error) { + return _NegRiskCTFExchange.Contract.DomainSeparator(&_NegRiskCTFExchange.CallOpts) +} + +// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. +// +// Solidity: function getCollateral() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetCollateral(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getCollateral") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. +// +// Solidity: function getCollateral() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetCollateral() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetCollateral(&_NegRiskCTFExchange.CallOpts) +} + +// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. +// +// Solidity: function getCollateral() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetCollateral() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetCollateral(&_NegRiskCTFExchange.CallOpts) +} + +// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. +// +// Solidity: function getComplement(uint256 token) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetComplement(opts *bind.CallOpts, token *big.Int) (*big.Int, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getComplement", token) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. +// +// Solidity: function getComplement(uint256 token) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetComplement(token *big.Int) (*big.Int, error) { + return _NegRiskCTFExchange.Contract.GetComplement(&_NegRiskCTFExchange.CallOpts, token) +} + +// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. +// +// Solidity: function getComplement(uint256 token) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetComplement(token *big.Int) (*big.Int, error) { + return _NegRiskCTFExchange.Contract.GetComplement(&_NegRiskCTFExchange.CallOpts, token) +} + +// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. +// +// Solidity: function getConditionId(uint256 token) view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetConditionId(opts *bind.CallOpts, token *big.Int) ([32]byte, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getConditionId", token) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. +// +// Solidity: function getConditionId(uint256 token) view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetConditionId(token *big.Int) ([32]byte, error) { + return _NegRiskCTFExchange.Contract.GetConditionId(&_NegRiskCTFExchange.CallOpts, token) +} + +// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. +// +// Solidity: function getConditionId(uint256 token) view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetConditionId(token *big.Int) ([32]byte, error) { + return _NegRiskCTFExchange.Contract.GetConditionId(&_NegRiskCTFExchange.CallOpts, token) +} + +// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. +// +// Solidity: function getCtf() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetCtf(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getCtf") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. +// +// Solidity: function getCtf() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetCtf() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetCtf(&_NegRiskCTFExchange.CallOpts) +} + +// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. +// +// Solidity: function getCtf() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetCtf() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetCtf(&_NegRiskCTFExchange.CallOpts) +} + +// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. +// +// Solidity: function getMaxFeeRate() pure returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetMaxFeeRate(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getMaxFeeRate") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. +// +// Solidity: function getMaxFeeRate() pure returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetMaxFeeRate() (*big.Int, error) { + return _NegRiskCTFExchange.Contract.GetMaxFeeRate(&_NegRiskCTFExchange.CallOpts) +} + +// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. +// +// Solidity: function getMaxFeeRate() pure returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetMaxFeeRate() (*big.Int, error) { + return _NegRiskCTFExchange.Contract.GetMaxFeeRate(&_NegRiskCTFExchange.CallOpts) +} + +// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. +// +// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetOrderStatus(opts *bind.CallOpts, orderHash [32]byte) (OrderStatus, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getOrderStatus", orderHash) + + if err != nil { + return *new(OrderStatus), err + } + + out0 := *abi.ConvertType(out[0], new(OrderStatus)).(*OrderStatus) + + return out0, err + +} + +// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. +// +// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { + return _NegRiskCTFExchange.Contract.GetOrderStatus(&_NegRiskCTFExchange.CallOpts, orderHash) +} + +// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. +// +// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { + return _NegRiskCTFExchange.Contract.GetOrderStatus(&_NegRiskCTFExchange.CallOpts, orderHash) +} + +// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. +// +// Solidity: function getPolyProxyFactoryImplementation() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetPolyProxyFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getPolyProxyFactoryImplementation") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. +// +// Solidity: function getPolyProxyFactoryImplementation() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetPolyProxyFactoryImplementation() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetPolyProxyFactoryImplementation(&_NegRiskCTFExchange.CallOpts) +} + +// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. +// +// Solidity: function getPolyProxyFactoryImplementation() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetPolyProxyFactoryImplementation() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetPolyProxyFactoryImplementation(&_NegRiskCTFExchange.CallOpts) +} + +// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. +// +// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetPolyProxyWalletAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getPolyProxyWalletAddress", _addr) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. +// +// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetPolyProxyWalletAddress(&_NegRiskCTFExchange.CallOpts, _addr) +} + +// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. +// +// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetPolyProxyWalletAddress(&_NegRiskCTFExchange.CallOpts, _addr) +} + +// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. +// +// Solidity: function getProxyFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetProxyFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getProxyFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. +// +// Solidity: function getProxyFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetProxyFactory() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetProxyFactory(&_NegRiskCTFExchange.CallOpts) +} + +// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. +// +// Solidity: function getProxyFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetProxyFactory() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetProxyFactory(&_NegRiskCTFExchange.CallOpts) +} + +// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. +// +// Solidity: function getSafeAddress(address _addr) view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetSafeAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getSafeAddress", _addr) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. +// +// Solidity: function getSafeAddress(address _addr) view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetSafeAddress(_addr common.Address) (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetSafeAddress(&_NegRiskCTFExchange.CallOpts, _addr) +} + +// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. +// +// Solidity: function getSafeAddress(address _addr) view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetSafeAddress(_addr common.Address) (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetSafeAddress(&_NegRiskCTFExchange.CallOpts, _addr) +} + +// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. +// +// Solidity: function getSafeFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetSafeFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getSafeFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. +// +// Solidity: function getSafeFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetSafeFactory() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetSafeFactory(&_NegRiskCTFExchange.CallOpts) +} + +// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. +// +// Solidity: function getSafeFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetSafeFactory() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetSafeFactory(&_NegRiskCTFExchange.CallOpts) +} + +// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. +// +// Solidity: function getSafeFactoryImplementation() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetSafeFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "getSafeFactoryImplementation") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. +// +// Solidity: function getSafeFactoryImplementation() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetSafeFactoryImplementation() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetSafeFactoryImplementation(&_NegRiskCTFExchange.CallOpts) +} + +// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. +// +// Solidity: function getSafeFactoryImplementation() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetSafeFactoryImplementation() (common.Address, error) { + return _NegRiskCTFExchange.Contract.GetSafeFactoryImplementation(&_NegRiskCTFExchange.CallOpts) +} + +// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. +// +// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) HashOrder(opts *bind.CallOpts, order Order) ([32]byte, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "hashOrder", order) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. +// +// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) HashOrder(order Order) ([32]byte, error) { + return _NegRiskCTFExchange.Contract.HashOrder(&_NegRiskCTFExchange.CallOpts, order) +} + +// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. +// +// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) HashOrder(order Order) ([32]byte, error) { + return _NegRiskCTFExchange.Contract.HashOrder(&_NegRiskCTFExchange.CallOpts, order) +} + +// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. +// +// Solidity: function isAdmin(address usr) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) IsAdmin(opts *bind.CallOpts, usr common.Address) (bool, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "isAdmin", usr) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. +// +// Solidity: function isAdmin(address usr) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) IsAdmin(usr common.Address) (bool, error) { + return _NegRiskCTFExchange.Contract.IsAdmin(&_NegRiskCTFExchange.CallOpts, usr) +} + +// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. +// +// Solidity: function isAdmin(address usr) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) IsAdmin(usr common.Address) (bool, error) { + return _NegRiskCTFExchange.Contract.IsAdmin(&_NegRiskCTFExchange.CallOpts, usr) +} + +// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. +// +// Solidity: function isOperator(address usr) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) IsOperator(opts *bind.CallOpts, usr common.Address) (bool, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "isOperator", usr) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. +// +// Solidity: function isOperator(address usr) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) IsOperator(usr common.Address) (bool, error) { + return _NegRiskCTFExchange.Contract.IsOperator(&_NegRiskCTFExchange.CallOpts, usr) +} + +// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. +// +// Solidity: function isOperator(address usr) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) IsOperator(usr common.Address) (bool, error) { + return _NegRiskCTFExchange.Contract.IsOperator(&_NegRiskCTFExchange.CallOpts, usr) +} + +// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. +// +// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) IsValidNonce(opts *bind.CallOpts, usr common.Address, nonce *big.Int) (bool, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "isValidNonce", usr, nonce) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. +// +// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { + return _NegRiskCTFExchange.Contract.IsValidNonce(&_NegRiskCTFExchange.CallOpts, usr, nonce) +} + +// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. +// +// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { + return _NegRiskCTFExchange.Contract.IsValidNonce(&_NegRiskCTFExchange.CallOpts, usr, nonce) +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "nonces", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Nonces(arg0 common.Address) (*big.Int, error) { + return _NegRiskCTFExchange.Contract.Nonces(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Nonces(arg0 common.Address) (*big.Int, error) { + return _NegRiskCTFExchange.Contract.Nonces(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. +// +// Solidity: function operators(address ) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Operators(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "operators", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. +// +// Solidity: function operators(address ) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Operators(arg0 common.Address) (*big.Int, error) { + return _NegRiskCTFExchange.Contract.Operators(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. +// +// Solidity: function operators(address ) view returns(uint256) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Operators(arg0 common.Address) (*big.Int, error) { + return _NegRiskCTFExchange.Contract.Operators(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. +// +// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) OrderStatus(opts *bind.CallOpts, arg0 [32]byte) (struct { + IsFilledOrCancelled bool + Remaining *big.Int +}, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "orderStatus", arg0) + + outstruct := new(struct { + IsFilledOrCancelled bool + Remaining *big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.IsFilledOrCancelled = *abi.ConvertType(out[0], new(bool)).(*bool) + outstruct.Remaining = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. +// +// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) OrderStatus(arg0 [32]byte) (struct { + IsFilledOrCancelled bool + Remaining *big.Int +}, error) { + return _NegRiskCTFExchange.Contract.OrderStatus(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. +// +// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) OrderStatus(arg0 [32]byte) (struct { + IsFilledOrCancelled bool + Remaining *big.Int +}, error) { + return _NegRiskCTFExchange.Contract.OrderStatus(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. +// +// Solidity: function parentCollectionId() view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ParentCollectionId(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "parentCollectionId") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. +// +// Solidity: function parentCollectionId() view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ParentCollectionId() ([32]byte, error) { + return _NegRiskCTFExchange.Contract.ParentCollectionId(&_NegRiskCTFExchange.CallOpts) +} + +// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. +// +// Solidity: function parentCollectionId() view returns(bytes32) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ParentCollectionId() ([32]byte, error) { + return _NegRiskCTFExchange.Contract.ParentCollectionId(&_NegRiskCTFExchange.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Paused(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "paused") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Paused() (bool, error) { + return _NegRiskCTFExchange.Contract.Paused(&_NegRiskCTFExchange.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Paused() (bool, error) { + return _NegRiskCTFExchange.Contract.Paused(&_NegRiskCTFExchange.CallOpts) +} + +// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. +// +// Solidity: function proxyFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ProxyFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "proxyFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. +// +// Solidity: function proxyFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ProxyFactory() (common.Address, error) { + return _NegRiskCTFExchange.Contract.ProxyFactory(&_NegRiskCTFExchange.CallOpts) +} + +// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. +// +// Solidity: function proxyFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ProxyFactory() (common.Address, error) { + return _NegRiskCTFExchange.Contract.ProxyFactory(&_NegRiskCTFExchange.CallOpts) +} + +// Registry is a free data retrieval call binding the contract method 0x5893253c. +// +// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Registry(opts *bind.CallOpts, arg0 *big.Int) (struct { + Complement *big.Int + ConditionId [32]byte +}, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "registry", arg0) + + outstruct := new(struct { + Complement *big.Int + ConditionId [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.Complement = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.ConditionId = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// Registry is a free data retrieval call binding the contract method 0x5893253c. +// +// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Registry(arg0 *big.Int) (struct { + Complement *big.Int + ConditionId [32]byte +}, error) { + return _NegRiskCTFExchange.Contract.Registry(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// Registry is a free data retrieval call binding the contract method 0x5893253c. +// +// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Registry(arg0 *big.Int) (struct { + Complement *big.Int + ConditionId [32]byte +}, error) { + return _NegRiskCTFExchange.Contract.Registry(&_NegRiskCTFExchange.CallOpts, arg0) +} + +// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. +// +// Solidity: function safeFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) SafeFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "safeFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. +// +// Solidity: function safeFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) SafeFactory() (common.Address, error) { + return _NegRiskCTFExchange.Contract.SafeFactory(&_NegRiskCTFExchange.CallOpts) +} + +// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. +// +// Solidity: function safeFactory() view returns(address) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) SafeFactory() (common.Address, error) { + return _NegRiskCTFExchange.Contract.SafeFactory(&_NegRiskCTFExchange.CallOpts) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "supportsInterface", interfaceId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _NegRiskCTFExchange.Contract.SupportsInterface(&_NegRiskCTFExchange.CallOpts, interfaceId) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _NegRiskCTFExchange.Contract.SupportsInterface(&_NegRiskCTFExchange.CallOpts, interfaceId) +} + +// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. +// +// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ValidateComplement(opts *bind.CallOpts, token *big.Int, complement *big.Int) error { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "validateComplement", token, complement) + + if err != nil { + return err + } + + return err + +} + +// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. +// +// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ValidateComplement(token *big.Int, complement *big.Int) error { + return _NegRiskCTFExchange.Contract.ValidateComplement(&_NegRiskCTFExchange.CallOpts, token, complement) +} + +// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. +// +// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ValidateComplement(token *big.Int, complement *big.Int) error { + return _NegRiskCTFExchange.Contract.ValidateComplement(&_NegRiskCTFExchange.CallOpts, token, complement) +} + +// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. +// +// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ValidateOrder(opts *bind.CallOpts, order Order) error { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "validateOrder", order) + + if err != nil { + return err + } + + return err + +} + +// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. +// +// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ValidateOrder(order Order) error { + return _NegRiskCTFExchange.Contract.ValidateOrder(&_NegRiskCTFExchange.CallOpts, order) +} + +// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. +// +// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ValidateOrder(order Order) error { + return _NegRiskCTFExchange.Contract.ValidateOrder(&_NegRiskCTFExchange.CallOpts, order) +} + +// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. +// +// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ValidateOrderSignature(opts *bind.CallOpts, orderHash [32]byte, order Order) error { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "validateOrderSignature", orderHash, order) + + if err != nil { + return err + } + + return err + +} + +// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. +// +// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { + return _NegRiskCTFExchange.Contract.ValidateOrderSignature(&_NegRiskCTFExchange.CallOpts, orderHash, order) +} + +// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. +// +// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { + return _NegRiskCTFExchange.Contract.ValidateOrderSignature(&_NegRiskCTFExchange.CallOpts, orderHash, order) +} + +// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. +// +// Solidity: function validateTokenId(uint256 tokenId) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ValidateTokenId(opts *bind.CallOpts, tokenId *big.Int) error { + var out []interface{} + err := _NegRiskCTFExchange.contract.Call(opts, &out, "validateTokenId", tokenId) + + if err != nil { + return err + } + + return err + +} + +// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. +// +// Solidity: function validateTokenId(uint256 tokenId) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ValidateTokenId(tokenId *big.Int) error { + return _NegRiskCTFExchange.Contract.ValidateTokenId(&_NegRiskCTFExchange.CallOpts, tokenId) +} + +// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. +// +// Solidity: function validateTokenId(uint256 tokenId) view returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ValidateTokenId(tokenId *big.Int) error { + return _NegRiskCTFExchange.Contract.ValidateTokenId(&_NegRiskCTFExchange.CallOpts, tokenId) +} + +// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. +// +// Solidity: function addAdmin(address admin_) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) AddAdmin(opts *bind.TransactOpts, admin_ common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "addAdmin", admin_) +} + +// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. +// +// Solidity: function addAdmin(address admin_) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.AddAdmin(&_NegRiskCTFExchange.TransactOpts, admin_) +} + +// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. +// +// Solidity: function addAdmin(address admin_) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.AddAdmin(&_NegRiskCTFExchange.TransactOpts, admin_) +} + +// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. +// +// Solidity: function addOperator(address operator_) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) AddOperator(opts *bind.TransactOpts, operator_ common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "addOperator", operator_) +} + +// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. +// +// Solidity: function addOperator(address operator_) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.AddOperator(&_NegRiskCTFExchange.TransactOpts, operator_) +} + +// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. +// +// Solidity: function addOperator(address operator_) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.AddOperator(&_NegRiskCTFExchange.TransactOpts, operator_) +} + +// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. +// +// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) CancelOrder(opts *bind.TransactOpts, order Order) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "cancelOrder", order) +} + +// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. +// +// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) CancelOrder(order Order) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.CancelOrder(&_NegRiskCTFExchange.TransactOpts, order) +} + +// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. +// +// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) CancelOrder(order Order) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.CancelOrder(&_NegRiskCTFExchange.TransactOpts, order) +} + +// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. +// +// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) CancelOrders(opts *bind.TransactOpts, orders []Order) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "cancelOrders", orders) +} + +// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. +// +// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) CancelOrders(orders []Order) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.CancelOrders(&_NegRiskCTFExchange.TransactOpts, orders) +} + +// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. +// +// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) CancelOrders(orders []Order) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.CancelOrders(&_NegRiskCTFExchange.TransactOpts, orders) +} + +// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. +// +// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) FillOrder(opts *bind.TransactOpts, order Order, fillAmount *big.Int) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "fillOrder", order, fillAmount) +} + +// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. +// +// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.FillOrder(&_NegRiskCTFExchange.TransactOpts, order, fillAmount) +} + +// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. +// +// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.FillOrder(&_NegRiskCTFExchange.TransactOpts, order, fillAmount) +} + +// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. +// +// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) FillOrders(opts *bind.TransactOpts, orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "fillOrders", orders, fillAmounts) +} + +// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. +// +// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.FillOrders(&_NegRiskCTFExchange.TransactOpts, orders, fillAmounts) +} + +// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. +// +// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.FillOrders(&_NegRiskCTFExchange.TransactOpts, orders, fillAmounts) +} + +// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. +// +// Solidity: function incrementNonce() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) IncrementNonce(opts *bind.TransactOpts) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "incrementNonce") +} + +// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. +// +// Solidity: function incrementNonce() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) IncrementNonce() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.IncrementNonce(&_NegRiskCTFExchange.TransactOpts) +} + +// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. +// +// Solidity: function incrementNonce() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) IncrementNonce() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.IncrementNonce(&_NegRiskCTFExchange.TransactOpts) +} + +// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. +// +// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) MatchOrders(opts *bind.TransactOpts, takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "matchOrders", takerOrder, makerOrders, takerFillAmount, makerFillAmounts) +} + +// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. +// +// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.MatchOrders(&_NegRiskCTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) +} + +// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. +// +// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.MatchOrders(&_NegRiskCTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) +} + +// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. +// +// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "onERC1155BatchReceived", arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. +// +// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.OnERC1155BatchReceived(&_NegRiskCTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. +// +// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.OnERC1155BatchReceived(&_NegRiskCTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. +// +// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "onERC1155Received", arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. +// +// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.OnERC1155Received(&_NegRiskCTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. +// +// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.OnERC1155Received(&_NegRiskCTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. +// +// Solidity: function pauseTrading() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) PauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "pauseTrading") +} + +// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. +// +// Solidity: function pauseTrading() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) PauseTrading() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.PauseTrading(&_NegRiskCTFExchange.TransactOpts) +} + +// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. +// +// Solidity: function pauseTrading() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) PauseTrading() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.PauseTrading(&_NegRiskCTFExchange.TransactOpts) +} + +// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. +// +// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RegisterToken(opts *bind.TransactOpts, token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "registerToken", token, complement, conditionId) +} + +// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. +// +// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RegisterToken(&_NegRiskCTFExchange.TransactOpts, token, complement, conditionId) +} + +// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. +// +// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RegisterToken(&_NegRiskCTFExchange.TransactOpts, token, complement, conditionId) +} + +// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. +// +// Solidity: function removeAdmin(address admin) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RemoveAdmin(opts *bind.TransactOpts, admin common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "removeAdmin", admin) +} + +// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. +// +// Solidity: function removeAdmin(address admin) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RemoveAdmin(&_NegRiskCTFExchange.TransactOpts, admin) +} + +// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. +// +// Solidity: function removeAdmin(address admin) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RemoveAdmin(&_NegRiskCTFExchange.TransactOpts, admin) +} + +// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. +// +// Solidity: function removeOperator(address operator) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RemoveOperator(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "removeOperator", operator) +} + +// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. +// +// Solidity: function removeOperator(address operator) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RemoveOperator(&_NegRiskCTFExchange.TransactOpts, operator) +} + +// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. +// +// Solidity: function removeOperator(address operator) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RemoveOperator(&_NegRiskCTFExchange.TransactOpts, operator) +} + +// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. +// +// Solidity: function renounceAdminRole() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RenounceAdminRole(opts *bind.TransactOpts) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "renounceAdminRole") +} + +// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. +// +// Solidity: function renounceAdminRole() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RenounceAdminRole() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RenounceAdminRole(&_NegRiskCTFExchange.TransactOpts) +} + +// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. +// +// Solidity: function renounceAdminRole() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RenounceAdminRole() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RenounceAdminRole(&_NegRiskCTFExchange.TransactOpts) +} + +// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. +// +// Solidity: function renounceOperatorRole() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RenounceOperatorRole(opts *bind.TransactOpts) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "renounceOperatorRole") +} + +// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. +// +// Solidity: function renounceOperatorRole() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RenounceOperatorRole() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RenounceOperatorRole(&_NegRiskCTFExchange.TransactOpts) +} + +// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. +// +// Solidity: function renounceOperatorRole() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RenounceOperatorRole() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.RenounceOperatorRole(&_NegRiskCTFExchange.TransactOpts) +} + +// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. +// +// Solidity: function setProxyFactory(address _newProxyFactory) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) SetProxyFactory(opts *bind.TransactOpts, _newProxyFactory common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "setProxyFactory", _newProxyFactory) +} + +// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. +// +// Solidity: function setProxyFactory(address _newProxyFactory) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.SetProxyFactory(&_NegRiskCTFExchange.TransactOpts, _newProxyFactory) +} + +// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. +// +// Solidity: function setProxyFactory(address _newProxyFactory) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.SetProxyFactory(&_NegRiskCTFExchange.TransactOpts, _newProxyFactory) +} + +// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. +// +// Solidity: function setSafeFactory(address _newSafeFactory) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) SetSafeFactory(opts *bind.TransactOpts, _newSafeFactory common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "setSafeFactory", _newSafeFactory) +} + +// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. +// +// Solidity: function setSafeFactory(address _newSafeFactory) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.SetSafeFactory(&_NegRiskCTFExchange.TransactOpts, _newSafeFactory) +} + +// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. +// +// Solidity: function setSafeFactory(address _newSafeFactory) returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.SetSafeFactory(&_NegRiskCTFExchange.TransactOpts, _newSafeFactory) +} + +// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. +// +// Solidity: function unpauseTrading() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) UnpauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { + return _NegRiskCTFExchange.contract.Transact(opts, "unpauseTrading") +} + +// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. +// +// Solidity: function unpauseTrading() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) UnpauseTrading() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.UnpauseTrading(&_NegRiskCTFExchange.TransactOpts) +} + +// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. +// +// Solidity: function unpauseTrading() returns() +func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) UnpauseTrading() (*types.Transaction, error) { + return _NegRiskCTFExchange.Contract.UnpauseTrading(&_NegRiskCTFExchange.TransactOpts) +} + +// NegRiskCTFExchangeFeeChargedIterator is returned from FilterFeeCharged and is used to iterate over the raw logs and unpacked data for FeeCharged events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeFeeChargedIterator struct { + Event *NegRiskCTFExchangeFeeCharged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeFeeChargedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeFeeCharged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeFeeCharged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeFeeChargedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeFeeChargedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeFeeCharged represents a FeeCharged event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeFeeCharged struct { + Receiver common.Address + TokenId *big.Int + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterFeeCharged is a free log retrieval operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. +// +// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterFeeCharged(opts *bind.FilterOpts, receiver []common.Address) (*NegRiskCTFExchangeFeeChargedIterator, error) { + + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "FeeCharged", receiverRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeFeeChargedIterator{contract: _NegRiskCTFExchange.contract, event: "FeeCharged", logs: logs, sub: sub}, nil +} + +// WatchFeeCharged is a free log subscription operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. +// +// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchFeeCharged(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeFeeCharged, receiver []common.Address) (event.Subscription, error) { + + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "FeeCharged", receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeFeeCharged) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseFeeCharged is a log parse operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. +// +// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseFeeCharged(log types.Log) (*NegRiskCTFExchangeFeeCharged, error) { + event := new(NegRiskCTFExchangeFeeCharged) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeNewAdminIterator is returned from FilterNewAdmin and is used to iterate over the raw logs and unpacked data for NewAdmin events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeNewAdminIterator struct { + Event *NegRiskCTFExchangeNewAdmin // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeNewAdminIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeNewAdminIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeNewAdminIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeNewAdmin represents a NewAdmin event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeNewAdmin struct { + NewAdminAddress common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewAdmin is a free log retrieval operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. +// +// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterNewAdmin(opts *bind.FilterOpts, newAdminAddress []common.Address, admin []common.Address) (*NegRiskCTFExchangeNewAdminIterator, error) { + + var newAdminAddressRule []interface{} + for _, newAdminAddressItem := range newAdminAddress { + newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeNewAdminIterator{contract: _NegRiskCTFExchange.contract, event: "NewAdmin", logs: logs, sub: sub}, nil +} + +// WatchNewAdmin is a free log subscription operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. +// +// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchNewAdmin(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeNewAdmin, newAdminAddress []common.Address, admin []common.Address) (event.Subscription, error) { + + var newAdminAddressRule []interface{} + for _, newAdminAddressItem := range newAdminAddress { + newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeNewAdmin) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewAdmin is a log parse operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. +// +// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseNewAdmin(log types.Log) (*NegRiskCTFExchangeNewAdmin, error) { + event := new(NegRiskCTFExchangeNewAdmin) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeNewOperatorIterator is returned from FilterNewOperator and is used to iterate over the raw logs and unpacked data for NewOperator events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeNewOperatorIterator struct { + Event *NegRiskCTFExchangeNewOperator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeNewOperatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeNewOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeNewOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeNewOperatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeNewOperatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeNewOperator represents a NewOperator event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeNewOperator struct { + NewOperatorAddress common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewOperator is a free log retrieval operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. +// +// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterNewOperator(opts *bind.FilterOpts, newOperatorAddress []common.Address, admin []common.Address) (*NegRiskCTFExchangeNewOperatorIterator, error) { + + var newOperatorAddressRule []interface{} + for _, newOperatorAddressItem := range newOperatorAddress { + newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeNewOperatorIterator{contract: _NegRiskCTFExchange.contract, event: "NewOperator", logs: logs, sub: sub}, nil +} + +// WatchNewOperator is a free log subscription operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. +// +// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchNewOperator(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeNewOperator, newOperatorAddress []common.Address, admin []common.Address) (event.Subscription, error) { + + var newOperatorAddressRule []interface{} + for _, newOperatorAddressItem := range newOperatorAddress { + newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeNewOperator) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewOperator is a log parse operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. +// +// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseNewOperator(log types.Log) (*NegRiskCTFExchangeNewOperator, error) { + event := new(NegRiskCTFExchangeNewOperator) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeOrderCancelledIterator is returned from FilterOrderCancelled and is used to iterate over the raw logs and unpacked data for OrderCancelled events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeOrderCancelledIterator struct { + Event *NegRiskCTFExchangeOrderCancelled // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeOrderCancelledIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeOrderCancelled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeOrderCancelled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeOrderCancelledIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeOrderCancelledIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeOrderCancelled represents a OrderCancelled event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeOrderCancelled struct { + OrderHash [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOrderCancelled is a free log retrieval operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. +// +// Solidity: event OrderCancelled(bytes32 indexed orderHash) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterOrderCancelled(opts *bind.FilterOpts, orderHash [][32]byte) (*NegRiskCTFExchangeOrderCancelledIterator, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "OrderCancelled", orderHashRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeOrderCancelledIterator{contract: _NegRiskCTFExchange.contract, event: "OrderCancelled", logs: logs, sub: sub}, nil +} + +// WatchOrderCancelled is a free log subscription operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. +// +// Solidity: event OrderCancelled(bytes32 indexed orderHash) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchOrderCancelled(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeOrderCancelled, orderHash [][32]byte) (event.Subscription, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "OrderCancelled", orderHashRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeOrderCancelled) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOrderCancelled is a log parse operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. +// +// Solidity: event OrderCancelled(bytes32 indexed orderHash) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseOrderCancelled(log types.Log) (*NegRiskCTFExchangeOrderCancelled, error) { + event := new(NegRiskCTFExchangeOrderCancelled) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeOrderFilledIterator is returned from FilterOrderFilled and is used to iterate over the raw logs and unpacked data for OrderFilled events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeOrderFilledIterator struct { + Event *NegRiskCTFExchangeOrderFilled // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeOrderFilledIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeOrderFilled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeOrderFilled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeOrderFilledIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeOrderFilledIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeOrderFilled represents a OrderFilled event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeOrderFilled struct { + OrderHash [32]byte + Maker common.Address + Taker common.Address + MakerAssetId *big.Int + TakerAssetId *big.Int + MakerAmountFilled *big.Int + TakerAmountFilled *big.Int + Fee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOrderFilled is a free log retrieval operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. +// +// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterOrderFilled(opts *bind.FilterOpts, orderHash [][32]byte, maker []common.Address, taker []common.Address) (*NegRiskCTFExchangeOrderFilledIterator, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + var makerRule []interface{} + for _, makerItem := range maker { + makerRule = append(makerRule, makerItem) + } + var takerRule []interface{} + for _, takerItem := range taker { + takerRule = append(takerRule, takerItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeOrderFilledIterator{contract: _NegRiskCTFExchange.contract, event: "OrderFilled", logs: logs, sub: sub}, nil +} + +// WatchOrderFilled is a free log subscription operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. +// +// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchOrderFilled(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeOrderFilled, orderHash [][32]byte, maker []common.Address, taker []common.Address) (event.Subscription, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + var makerRule []interface{} + for _, makerItem := range maker { + makerRule = append(makerRule, makerItem) + } + var takerRule []interface{} + for _, takerItem := range taker { + takerRule = append(takerRule, takerItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeOrderFilled) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOrderFilled is a log parse operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. +// +// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseOrderFilled(log types.Log) (*NegRiskCTFExchangeOrderFilled, error) { + event := new(NegRiskCTFExchangeOrderFilled) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeOrdersMatchedIterator is returned from FilterOrdersMatched and is used to iterate over the raw logs and unpacked data for OrdersMatched events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeOrdersMatchedIterator struct { + Event *NegRiskCTFExchangeOrdersMatched // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeOrdersMatchedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeOrdersMatched) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeOrdersMatched) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeOrdersMatchedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeOrdersMatchedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeOrdersMatched represents a OrdersMatched event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeOrdersMatched struct { + TakerOrderHash [32]byte + TakerOrderMaker common.Address + MakerAssetId *big.Int + TakerAssetId *big.Int + MakerAmountFilled *big.Int + TakerAmountFilled *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOrdersMatched is a free log retrieval operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. +// +// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterOrdersMatched(opts *bind.FilterOpts, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (*NegRiskCTFExchangeOrdersMatchedIterator, error) { + + var takerOrderHashRule []interface{} + for _, takerOrderHashItem := range takerOrderHash { + takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) + } + var takerOrderMakerRule []interface{} + for _, takerOrderMakerItem := range takerOrderMaker { + takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeOrdersMatchedIterator{contract: _NegRiskCTFExchange.contract, event: "OrdersMatched", logs: logs, sub: sub}, nil +} + +// WatchOrdersMatched is a free log subscription operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. +// +// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchOrdersMatched(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeOrdersMatched, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (event.Subscription, error) { + + var takerOrderHashRule []interface{} + for _, takerOrderHashItem := range takerOrderHash { + takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) + } + var takerOrderMakerRule []interface{} + for _, takerOrderMakerItem := range takerOrderMaker { + takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeOrdersMatched) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOrdersMatched is a log parse operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. +// +// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseOrdersMatched(log types.Log) (*NegRiskCTFExchangeOrdersMatched, error) { + event := new(NegRiskCTFExchangeOrdersMatched) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeProxyFactoryUpdatedIterator is returned from FilterProxyFactoryUpdated and is used to iterate over the raw logs and unpacked data for ProxyFactoryUpdated events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeProxyFactoryUpdatedIterator struct { + Event *NegRiskCTFExchangeProxyFactoryUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeProxyFactoryUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeProxyFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeProxyFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeProxyFactoryUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeProxyFactoryUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeProxyFactoryUpdated represents a ProxyFactoryUpdated event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeProxyFactoryUpdated struct { + OldProxyFactory common.Address + NewProxyFactory common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterProxyFactoryUpdated is a free log retrieval operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. +// +// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterProxyFactoryUpdated(opts *bind.FilterOpts, oldProxyFactory []common.Address, newProxyFactory []common.Address) (*NegRiskCTFExchangeProxyFactoryUpdatedIterator, error) { + + var oldProxyFactoryRule []interface{} + for _, oldProxyFactoryItem := range oldProxyFactory { + oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) + } + var newProxyFactoryRule []interface{} + for _, newProxyFactoryItem := range newProxyFactory { + newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeProxyFactoryUpdatedIterator{contract: _NegRiskCTFExchange.contract, event: "ProxyFactoryUpdated", logs: logs, sub: sub}, nil +} + +// WatchProxyFactoryUpdated is a free log subscription operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. +// +// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchProxyFactoryUpdated(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeProxyFactoryUpdated, oldProxyFactory []common.Address, newProxyFactory []common.Address) (event.Subscription, error) { + + var oldProxyFactoryRule []interface{} + for _, oldProxyFactoryItem := range oldProxyFactory { + oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) + } + var newProxyFactoryRule []interface{} + for _, newProxyFactoryItem := range newProxyFactory { + newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeProxyFactoryUpdated) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseProxyFactoryUpdated is a log parse operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. +// +// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseProxyFactoryUpdated(log types.Log) (*NegRiskCTFExchangeProxyFactoryUpdated, error) { + event := new(NegRiskCTFExchangeProxyFactoryUpdated) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeRemovedAdminIterator is returned from FilterRemovedAdmin and is used to iterate over the raw logs and unpacked data for RemovedAdmin events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeRemovedAdminIterator struct { + Event *NegRiskCTFExchangeRemovedAdmin // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeRemovedAdminIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeRemovedAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeRemovedAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeRemovedAdminIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeRemovedAdminIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeRemovedAdmin represents a RemovedAdmin event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeRemovedAdmin struct { + RemovedAdmin common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemovedAdmin is a free log retrieval operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. +// +// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterRemovedAdmin(opts *bind.FilterOpts, removedAdmin []common.Address, admin []common.Address) (*NegRiskCTFExchangeRemovedAdminIterator, error) { + + var removedAdminRule []interface{} + for _, removedAdminItem := range removedAdmin { + removedAdminRule = append(removedAdminRule, removedAdminItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeRemovedAdminIterator{contract: _NegRiskCTFExchange.contract, event: "RemovedAdmin", logs: logs, sub: sub}, nil +} + +// WatchRemovedAdmin is a free log subscription operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. +// +// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchRemovedAdmin(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeRemovedAdmin, removedAdmin []common.Address, admin []common.Address) (event.Subscription, error) { + + var removedAdminRule []interface{} + for _, removedAdminItem := range removedAdmin { + removedAdminRule = append(removedAdminRule, removedAdminItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeRemovedAdmin) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemovedAdmin is a log parse operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. +// +// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseRemovedAdmin(log types.Log) (*NegRiskCTFExchangeRemovedAdmin, error) { + event := new(NegRiskCTFExchangeRemovedAdmin) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeRemovedOperatorIterator is returned from FilterRemovedOperator and is used to iterate over the raw logs and unpacked data for RemovedOperator events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeRemovedOperatorIterator struct { + Event *NegRiskCTFExchangeRemovedOperator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeRemovedOperatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeRemovedOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeRemovedOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeRemovedOperatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeRemovedOperatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeRemovedOperator represents a RemovedOperator event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeRemovedOperator struct { + RemovedOperator common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemovedOperator is a free log retrieval operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. +// +// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterRemovedOperator(opts *bind.FilterOpts, removedOperator []common.Address, admin []common.Address) (*NegRiskCTFExchangeRemovedOperatorIterator, error) { + + var removedOperatorRule []interface{} + for _, removedOperatorItem := range removedOperator { + removedOperatorRule = append(removedOperatorRule, removedOperatorItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeRemovedOperatorIterator{contract: _NegRiskCTFExchange.contract, event: "RemovedOperator", logs: logs, sub: sub}, nil +} + +// WatchRemovedOperator is a free log subscription operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. +// +// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchRemovedOperator(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeRemovedOperator, removedOperator []common.Address, admin []common.Address) (event.Subscription, error) { + + var removedOperatorRule []interface{} + for _, removedOperatorItem := range removedOperator { + removedOperatorRule = append(removedOperatorRule, removedOperatorItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeRemovedOperator) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemovedOperator is a log parse operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. +// +// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseRemovedOperator(log types.Log) (*NegRiskCTFExchangeRemovedOperator, error) { + event := new(NegRiskCTFExchangeRemovedOperator) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeSafeFactoryUpdatedIterator is returned from FilterSafeFactoryUpdated and is used to iterate over the raw logs and unpacked data for SafeFactoryUpdated events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeSafeFactoryUpdatedIterator struct { + Event *NegRiskCTFExchangeSafeFactoryUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeSafeFactoryUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeSafeFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeSafeFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeSafeFactoryUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeSafeFactoryUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeSafeFactoryUpdated represents a SafeFactoryUpdated event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeSafeFactoryUpdated struct { + OldSafeFactory common.Address + NewSafeFactory common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSafeFactoryUpdated is a free log retrieval operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. +// +// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterSafeFactoryUpdated(opts *bind.FilterOpts, oldSafeFactory []common.Address, newSafeFactory []common.Address) (*NegRiskCTFExchangeSafeFactoryUpdatedIterator, error) { + + var oldSafeFactoryRule []interface{} + for _, oldSafeFactoryItem := range oldSafeFactory { + oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) + } + var newSafeFactoryRule []interface{} + for _, newSafeFactoryItem := range newSafeFactory { + newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeSafeFactoryUpdatedIterator{contract: _NegRiskCTFExchange.contract, event: "SafeFactoryUpdated", logs: logs, sub: sub}, nil +} + +// WatchSafeFactoryUpdated is a free log subscription operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. +// +// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchSafeFactoryUpdated(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeSafeFactoryUpdated, oldSafeFactory []common.Address, newSafeFactory []common.Address) (event.Subscription, error) { + + var oldSafeFactoryRule []interface{} + for _, oldSafeFactoryItem := range oldSafeFactory { + oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) + } + var newSafeFactoryRule []interface{} + for _, newSafeFactoryItem := range newSafeFactory { + newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeSafeFactoryUpdated) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSafeFactoryUpdated is a log parse operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. +// +// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseSafeFactoryUpdated(log types.Log) (*NegRiskCTFExchangeSafeFactoryUpdated, error) { + event := new(NegRiskCTFExchangeSafeFactoryUpdated) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeTokenRegisteredIterator is returned from FilterTokenRegistered and is used to iterate over the raw logs and unpacked data for TokenRegistered events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeTokenRegisteredIterator struct { + Event *NegRiskCTFExchangeTokenRegistered // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeTokenRegisteredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeTokenRegistered) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeTokenRegistered) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeTokenRegisteredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeTokenRegisteredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeTokenRegistered represents a TokenRegistered event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeTokenRegistered struct { + Token0 *big.Int + Token1 *big.Int + ConditionId [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTokenRegistered is a free log retrieval operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. +// +// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterTokenRegistered(opts *bind.FilterOpts, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (*NegRiskCTFExchangeTokenRegisteredIterator, error) { + + var token0Rule []interface{} + for _, token0Item := range token0 { + token0Rule = append(token0Rule, token0Item) + } + var token1Rule []interface{} + for _, token1Item := range token1 { + token1Rule = append(token1Rule, token1Item) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeTokenRegisteredIterator{contract: _NegRiskCTFExchange.contract, event: "TokenRegistered", logs: logs, sub: sub}, nil +} + +// WatchTokenRegistered is a free log subscription operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. +// +// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchTokenRegistered(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeTokenRegistered, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (event.Subscription, error) { + + var token0Rule []interface{} + for _, token0Item := range token0 { + token0Rule = append(token0Rule, token0Item) + } + var token1Rule []interface{} + for _, token1Item := range token1 { + token1Rule = append(token1Rule, token1Item) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeTokenRegistered) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTokenRegistered is a log parse operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. +// +// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseTokenRegistered(log types.Log) (*NegRiskCTFExchangeTokenRegistered, error) { + event := new(NegRiskCTFExchangeTokenRegistered) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeTradingPausedIterator is returned from FilterTradingPaused and is used to iterate over the raw logs and unpacked data for TradingPaused events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeTradingPausedIterator struct { + Event *NegRiskCTFExchangeTradingPaused // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeTradingPausedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeTradingPaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeTradingPaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeTradingPausedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeTradingPausedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeTradingPaused represents a TradingPaused event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeTradingPaused struct { + Pauser common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTradingPaused is a free log retrieval operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. +// +// Solidity: event TradingPaused(address indexed pauser) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterTradingPaused(opts *bind.FilterOpts, pauser []common.Address) (*NegRiskCTFExchangeTradingPausedIterator, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "TradingPaused", pauserRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeTradingPausedIterator{contract: _NegRiskCTFExchange.contract, event: "TradingPaused", logs: logs, sub: sub}, nil +} + +// WatchTradingPaused is a free log subscription operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. +// +// Solidity: event TradingPaused(address indexed pauser) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchTradingPaused(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeTradingPaused, pauser []common.Address) (event.Subscription, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "TradingPaused", pauserRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeTradingPaused) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTradingPaused is a log parse operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. +// +// Solidity: event TradingPaused(address indexed pauser) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseTradingPaused(log types.Log) (*NegRiskCTFExchangeTradingPaused, error) { + event := new(NegRiskCTFExchangeTradingPaused) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// NegRiskCTFExchangeTradingUnpausedIterator is returned from FilterTradingUnpaused and is used to iterate over the raw logs and unpacked data for TradingUnpaused events raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeTradingUnpausedIterator struct { + Event *NegRiskCTFExchangeTradingUnpaused // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *NegRiskCTFExchangeTradingUnpausedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeTradingUnpaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(NegRiskCTFExchangeTradingUnpaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *NegRiskCTFExchangeTradingUnpausedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *NegRiskCTFExchangeTradingUnpausedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// NegRiskCTFExchangeTradingUnpaused represents a TradingUnpaused event raised by the NegRiskCTFExchange contract. +type NegRiskCTFExchangeTradingUnpaused struct { + Pauser common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTradingUnpaused is a free log retrieval operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. +// +// Solidity: event TradingUnpaused(address indexed pauser) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterTradingUnpaused(opts *bind.FilterOpts, pauser []common.Address) (*NegRiskCTFExchangeTradingUnpausedIterator, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "TradingUnpaused", pauserRule) + if err != nil { + return nil, err + } + return &NegRiskCTFExchangeTradingUnpausedIterator{contract: _NegRiskCTFExchange.contract, event: "TradingUnpaused", logs: logs, sub: sub}, nil +} + +// WatchTradingUnpaused is a free log subscription operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. +// +// Solidity: event TradingUnpaused(address indexed pauser) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchTradingUnpaused(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeTradingUnpaused, pauser []common.Address) (event.Subscription, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "TradingUnpaused", pauserRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(NegRiskCTFExchangeTradingUnpaused) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTradingUnpaused is a log parse operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. +// +// Solidity: event TradingUnpaused(address indexed pauser) +func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseTradingUnpaused(log types.Log) (*NegRiskCTFExchangeTradingUnpaused, error) { + event := new(NegRiskCTFExchangeTradingUnpaused) + if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} From 91e3d627aaf51074930b90d26d6155e449b59549 Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 16:56:19 +0800 Subject: [PATCH 04/19] fix: modify action names with updated protocol-go action enums --- .../engine/worker/decentralized/contract/nouns/worker.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/internal/engine/worker/decentralized/contract/nouns/worker.go b/internal/engine/worker/decentralized/contract/nouns/worker.go index 712ec9f5..6721255d 100644 --- a/internal/engine/worker/decentralized/contract/nouns/worker.go +++ b/internal/engine/worker/decentralized/contract/nouns/worker.go @@ -319,11 +319,11 @@ func (w *worker) handleNounsVote(_ context.Context, _ *source.Task, log *ethereu switch event.Support { case 0: - voteAction = metadata.ActionGovernanceAgainst + voteAction = metadata.ActionGovernanceVoteAgainst case 1: - voteAction = metadata.ActionGovernanceFor + voteAction = metadata.ActionGovernanceVoteFor case 2: - voteAction = metadata.ActionGovernanceAbstain + voteAction = metadata.ActionGovernanceVoteAbstain default: return nil, fmt.Errorf("invalid support value: %d", event.Support) } From 758be3fe050347f737e03be16b6ac8056b7ad1ba Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 16:57:28 +0800 Subject: [PATCH 05/19] fix: remove duplicated function declaration --- .../contract_neg_risk_ctf_exchange.go | 23 ------------------- 1 file changed, 23 deletions(-) diff --git a/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go b/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go index bd2aa0f0..f453d9e2 100644 --- a/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go +++ b/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go @@ -29,29 +29,6 @@ var ( _ = abi.ConvertType ) -// Order is an auto generated low-level Go binding around an user-defined struct. -type Order struct { - Salt *big.Int - Maker common.Address - Signer common.Address - Taker common.Address - TokenId *big.Int - MakerAmount *big.Int - TakerAmount *big.Int - Expiration *big.Int - Nonce *big.Int - FeeRateBps *big.Int - Side uint8 - SignatureType uint8 - Signature []byte -} - -// OrderStatus is an auto generated low-level Go binding around an user-defined struct. -type OrderStatus struct { - IsFilledOrCancelled bool - Remaining *big.Int -} - // NegRiskCTFExchangeMetaData contains all meta data concerning the NegRiskCTFExchange contract. var NegRiskCTFExchangeMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_ctf\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_negRiskAdapter\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_proxyFactory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_safeFactory\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FeeTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidComplement\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenId\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MakingGtRemaining\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MismatchedTokenIds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCrossing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOperator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderFilledOrCancelled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLittleTokensReceived\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"FeeCharged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newAdminAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOperatorAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderCancelled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"OrderFilled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"takerOrderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"takerOrderMaker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"}],\"name\":\"OrdersMatched\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldProxyFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProxyFactory\",\"type\":\"address\"}],\"name\":\"ProxyFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedAdmin\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedOperator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldSafeFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newSafeFactory\",\"type\":\"address\"}],\"name\":\"SafeFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token0\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"TokenRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingUnpaused\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"name\":\"addAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator_\",\"type\":\"address\"}],\"name\":\"addOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"admins\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"cancelOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"cancelOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"domainSeparator\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"fillAmount\",\"type\":\"uint256\"}],\"name\":\"fillOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"fillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"fillOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateral\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getComplement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCtf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getMaxFeeRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"getOrderStatus\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"internalType\":\"structOrderStatus\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPolyProxyFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getPolyProxyWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getProxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getSafeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isAdmin\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"isValidNonce\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"takerOrder\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"makerOrders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"takerFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"makerFillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"matchOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"operators\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"orderStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parentCollectionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"registerToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"removeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"removeOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOperatorRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"safeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProxyFactory\",\"type\":\"address\"}],\"name\":\"setProxyFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newSafeFactory\",\"type\":\"address\"}],\"name\":\"setSafeFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"}],\"name\":\"validateComplement\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrder\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrderSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"validateTokenId\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", From 72302f104e580c81c0fffebb21a34938c67d0788 Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 17:01:48 +0800 Subject: [PATCH 06/19] fix: add go.sum --- go.sum | 723 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 723 insertions(+) create mode 100644 go.sum diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..8d414501 --- /dev/null +++ b/go.sum @@ -0,0 +1,723 @@ +dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= +dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= +filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= +github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0= +github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/DataDog/zstd v1.5.0 h1:+K/VEwIAaPcHiMtQvpLD4lqW7f0Gk3xdYZmI1hD+CXo= +github.com/DataDog/zstd v1.5.0/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= +github.com/JohannesKaufmann/html-to-markdown v1.6.0 h1:04VXMiE50YYfCfLboJCLcgqF5x+rHJnb1ssNmqpLH/k= +github.com/JohannesKaufmann/html-to-markdown v1.6.0/go.mod h1:NUI78lGg/a7vpEJTz/0uOcYMaibytE4BUOQS8k78yPQ= +github.com/Khan/genqlient v0.7.0 h1:GZ1meyRnzcDTK48EjqB8t3bcfYvHArCUUvgOwpz1D4w= +github.com/Khan/genqlient v0.7.0/go.mod h1:HNyy3wZvuYwmW3Y7mkoQLZsa/R5n5yIRajS1kPBvSFM= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw= +github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= +github.com/PuerkitoBio/goquery v1.9.2 h1:4/wZksC3KgkQw7SQgkKotmKljk0M6V8TUvA8Wb4yPeE= +github.com/PuerkitoBio/goquery v1.9.2/go.mod h1:GHPCaP0ODyyxqcNoFGYlAprUFH81NuRPd0GX3Zu2Mvk= +github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= +github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= +github.com/adrianbrad/psqldocker v1.2.1 h1:bvsRmbotpA89ruqGGzzaAZUBtDaIk98gO+JMBNVSZlI= +github.com/adrianbrad/psqldocker v1.2.1/go.mod h1:LbCnIy60YO6IRJYrF1r+eafKUgU9UnkSFx0gT8UiaUs= +github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ= +github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= +github.com/andybalholm/cascadia v1.2.0/go.mod h1:YCyR8vOZT9aZ1CHEd8ap0gMVm2aFgxBp0T0eFw1RUQY= +github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= +github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= +github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA= +github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE= +github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= +github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U= +github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2 h1:KdUfX2zKommPRa+PD0sWZUyXe9w277ABlgELO7H04IM= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= +github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= +github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cockroachdb/errors v1.8.1 h1:A5+txlVZfOqFBDa4mGz2bUWSp0aHElvHX2bKkdbQu+Y= +github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac= +github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f h1:o/kfcElHqOiXqcou5a3rIlMc7oJbMQkeLk0VQJ7zgqY= +github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= +github.com/cockroachdb/redact v1.0.8 h1:8QG/764wK+vmEYoOlfobpe12EQcS81ukx/a4hdVMxNw= +github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 h1:IKgmqgMQlVJIZj19CdocBeSfSaiCbEBZGKODaixqtHM= +github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= +github.com/containerd/continuity v0.4.3 h1:6HVkalIp+2u1ZLH1J/pYX2oBVXlJZvh1X1A7bEZ9Su8= +github.com/containerd/continuity v0.4.3/go.mod h1:F6PTNCKepoxEaXLQp3wDAjygEnImnZ/7o4JzpodfroQ= +github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= +github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= +github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4= +github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= +github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY= +github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= +github.com/creasty/defaults v1.8.0 h1:z27FJxCAa0JKt3utc0sCImAEb+spPucmKoOdLHvHYKk= +github.com/creasty/defaults v1.8.0/go.mod h1:iGzKe6pbEHnpMPtfDXZEr0NVxWnPTjb1bbDy08fPzYM= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/deckarep/golang-set/v2 v2.3.1 h1:vjmkvJt/IV27WXPyYQpAh4bRyWJc5Y435D17XQ9QU5A= +github.com/deckarep/golang-set/v2 v2.3.1/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y= +github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= +github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= +github.com/docker/cli v26.1.1+incompatible h1:bE1/uE2tCa08fMv+7ikLR/RDPoCqytwrLtkIkSzxLvw= +github.com/docker/cli v26.1.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= +github.com/docker/docker v26.1.3+incompatible h1:lLCzRbrVZrljpVNobJu1J2FHk8V0s4BawoZippkc+xo= +github.com/docker/docker v26.1.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c= +github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc= +github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= +github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= +github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= +github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= +github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.13.15 h1:U7sSGYGo4SPjP6iNIifNoyIAiNjrmQkz6EwQG+/EZWo= +github.com/ethereum/go-ethereum v1.13.15/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA= +github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= +github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4= +github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= +github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/form/v4 v4.2.1 h1:HjdRDKO0fftVMU5epjPW2SOREcZ6/wLUzEobqUGJuPw= +github.com/go-playground/form/v4 v4.2.1/go.mod h1:q1a2BY+AQUUzhl6xA/6hBetay6dEIhMHjgvJiGo6K7U= +github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= +github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= +github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= +github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= +github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA= +github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM= +github.com/go-redis/redis v6.15.9+incompatible h1:K0pv1D7EQUjfyoMql+r/jZqCLizCGKFlFgcHWWmHQjg= +github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA= +github.com/go-redis/redis/v7 v7.4.1 h1:PASvf36gyUpr2zdOUS/9Zqc80GbM+9BDyiJSJDDOrTI= +github.com/go-redis/redis/v7 v7.4.1/go.mod h1:JDNMw23GTyLNC4GZu9njt15ctBQVn7xjRfnwdHj/Dcg= +github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI= +github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo= +github.com/go-redsync/redsync/v4 v4.13.0 h1:49X6GJfnbLGaIpBBREM/zA4uIMDXKAh1NDkvQ1EkZKA= +github.com/go-redsync/redsync/v4 v4.13.0/go.mod h1:HMW4Q224GZQz6x1Xc7040Yfgacukdzu7ifTDAKiyErQ= +github.com/go-shiori/dom v0.0.0-20210627111528-4e4722cd0d65 h1:zx4B0AiwqKDQq+AgqxWeHwbbLJQeidq20hgfP+aMNWI= +github.com/go-shiori/dom v0.0.0-20210627111528-4e4722cd0d65/go.mod h1:NPO1+buE6TYOWhUI98/hXLHHJhunIpXRuvDN4xjkCoE= +github.com/go-shiori/go-readability v0.0.0-20231029095239-6b97d5aba789 h1:G6wSuUyCoLB9jrUokipsmFuRi8aJozt3phw/g9Sl4Xs= +github.com/go-shiori/go-readability v0.0.0-20231029095239-6b97d5aba789/go.mod h1:2DpZlTJO/ycxp/vsc/C11oUyveStOgIXB88SYV1lncI= +github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y= +github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= +github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= +github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= +github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= +github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/gogs/chardet v0.0.0-20191104214054-4b6791f73a28/go.mod h1:Pcatq5tYkCW2Q6yrR2VRHlbHpZ/R4/7qyL1TCF7vl14= +github.com/gogs/chardet v0.0.0-20211120154057-b7413eaefb8f h1:3BSP1Tbs2djlpprl7wCLuiqMaUh5SJkkzI2gDs+FgLs= +github.com/gogs/chardet v0.0.0-20211120154057-b7413eaefb8f/go.mod h1:Pcatq5tYkCW2Q6yrR2VRHlbHpZ/R4/7qyL1TCF7vl14= +github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= +github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= +github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/gomodule/redigo v1.8.9 h1:Sl3u+2BI/kk+VEatbj0scLdrFhjPmbxOc1myhDP41ws= +github.com/gomodule/redigo v1.8.9/go.mod h1:7ArFNvsTjH8GMMzB4uy1snslv2BwmginuMs06a1uzZE= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8 h1:FKHo8hFI3A+7w0aUQuYXQ+6EN5stWmeY/AZqtM8xk9k= +github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= +github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/grafana/pyroscope-go v1.1.2 h1:7vCfdORYQMCxIzI3NlYAs3FcBP760+gWuYWOyiVyYx8= +github.com/grafana/pyroscope-go v1.1.2/go.mod h1:HSSmHo2KRn6FasBA4vK7BMiQqyQq8KSuBKvrhkXxYPU= +github.com/grafana/pyroscope-go/godeltaprof v0.1.8 h1:iwOtYXeeVSAeYefJNaxDytgjKtUuKQbJqgAIjlnicKg= +github.com/grafana/pyroscope-go/godeltaprof v0.1.8/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I= +github.com/hamba/avro v1.8.0 h1:eCVrLX7UYThA3R3yBZ+rpmafA5qTc3ZjpTz6gYJoVGU= +github.com/hamba/avro v1.8.0/go.mod h1:NiGUcrLLT+CKfGu5REWQtD9OVPPYUGMVFiC+DE0lQfY= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= +github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= +github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= +github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= +github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= +github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +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/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4= +github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= +github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= +github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= +github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= +github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= +github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 h1:L0QtFUgDarD7Fpv9jeVMgy/+Ec0mtnmYuImjTz6dtDA= +github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY= +github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw= +github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= +github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= +github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= +github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= +github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= +github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= +github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= +github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= +github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg= +github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/labstack/echo/v4 v4.12.0 h1:IKpw49IMryVB2p1a4dzwlhP1O2Tf2E0Ir/450lH+kI0= +github.com/labstack/echo/v4 v4.12.0/go.mod h1:UP9Cr2DJXbOK3Kr9ONYzNowSh7HP0aG0ShAyycHSJvM= +github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0= +github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU= +github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= +github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= +github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= +github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= +github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= +github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= +github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ= +github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= +github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY= +github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg= +github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= +github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= +github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= +github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= +github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= +github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= +github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= +github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= +github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0= +github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= +github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= +github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= +github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= +github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE= +github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI= +github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0= +github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4= +github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g= +github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk= +github.com/multiformats/go-multicodec v0.9.0 h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg= +github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k= +github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U= +github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM= +github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8= +github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +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/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= +github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= +github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= +github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= +github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= +github.com/onsi/ginkgo/v2 v2.20.1 h1:YlVIbqct+ZmnEph770q9Q7NVAz4wwIiVNahee6JyUzo= +github.com/onsi/ginkgo/v2 v2.20.1/go.mod h1:lG9ey2Z29hR41WMVthyJBGUBcBhGOtoPF2VFMvBXFCI= +github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +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.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k= +github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY= +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.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug= +github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= +github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss= +github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8= +github.com/orlangure/gnomock v0.31.0 h1:dgjlQ8DYUPMyNwMZJuYBH+/GF+e7h3sloldPzIJF4k4= +github.com/orlangure/gnomock v0.31.0/go.mod h1:RagxeYv3bKi+li9Lio2Faw5t6Mcy4akkeqXzkgAS3w0= +github.com/ory/dockertest/v3 v3.10.0 h1:4K3z2VMe8Woe++invjaTB7VRyQXQy5UY+loujO4aNE4= +github.com/ory/dockertest/v3 v3.10.0/go.mod h1:nr57ZbRWMqfsdGdFNLHz5jjNdDb7VVFnzAeW1n5N1Lg= +github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= +github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= +github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ= +github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pressly/goose/v3 v3.22.0 h1:wd/7kNiPTuNAztWun7iaB98DrhulbWPrzMAaw2DEZNw= +github.com/pressly/goose/v3 v3.22.0/go.mod h1:yJM3qwSj2pp7aAaCvso096sguezamNb2OBgxCnh/EYg= +github.com/prometheus/client_golang v1.20.3 h1:oPksm4K8B+Vt35tUhw6GbSNSgVlVSBH0qELP/7u83l4= +github.com/prometheus/client_golang v1.20.3/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= +github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= +github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= +github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc= +github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8= +github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= +github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= +github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8= +github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= +github.com/redis/rueidis v1.0.45 h1:j7hfcqfLLIqgTK3IkxBhXdeJcP34t3XLXvorDLqXfgM= +github.com/redis/rueidis v1.0.45/go.mod h1:by+34b0cFXndxtYmPAHpoTHO5NkosDlBvhexoTURIxM= +github.com/redis/rueidis/mock v1.0.45 h1:r2LRiwOtFib8+NAuVxNmcdxL7IMUk3as9IGPzx2v5tA= +github.com/redis/rueidis/mock v1.0.45/go.mod h1:bjpk7ox5jwue03L8NpjgPBE91tLkm9Amla+XFYhaezc= +github.com/redis/rueidis/rueidiscompat v1.0.45 h1:G+3HIaETgtwr6aL6BOTFCa2DfpPDhxqcoiDn8cvd5Ps= +github.com/redis/rueidis/rueidiscompat v1.0.45/go.mod h1:JMw3cktmwNqsSl2npjcxrOfLa1L3rmj1Ox5aPHiDjOU= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs= +github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= +github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= +github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= +github.com/rss3-network/protocol-go v0.5.7 h1:EpZ/WiQzSMpUmvf0dWrZb+o0H+ntfG6/IW5NNoPx+PA= +github.com/rss3-network/protocol-go v0.5.7/go.mod h1:npcyduWt86uVbIi77xQaYk8eqltI9XNjk1FMGpjyIq0= +github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= +github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= +github.com/samber/lo v1.47.0 h1:z7RynLwP5nbyRscyvcD043DWYoOcYRv3mV8lBeqOCLc= +github.com/samber/lo v1.47.0/go.mod h1:RmDH9Ct32Qy3gduHQuKJ3gW1fMHAnE/fAzQuf6He5cU= +github.com/sebdah/goldie/v2 v2.5.3 h1:9ES/mNN+HNUbNWpVAlrzuZ7jE+Nrczbj8uFRjM7624Y= +github.com/sebdah/goldie/v2 v2.5.3/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI= +github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= +github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8= +github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I= +github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE= +github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas= +github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= +github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= +github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= +github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= +github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= +github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= +github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= +github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0= +github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= +github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM= +github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI= +github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg= +github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= +github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203 h1:QVqDTf3h2WHt08YuiTGPZLls0Wq99X9bWd0Q5ZSBesM= +github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203/go.mod h1:oqN97ltKNihBbwlX8dLpwxCl3+HnXKV/R0e+sRLd9C8= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= +github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= +github.com/tdewolff/minify/v2 v2.20.37 h1:Q97cx4STXCh1dlWDlNHZniE8BJ2EBL0+2b0n92BJQhw= +github.com/tdewolff/minify/v2 v2.20.37/go.mod h1:L1VYef/jwKw6Wwyk5A+T0mBjjn3mMPgmjjA688RNsxU= +github.com/tdewolff/parse/v2 v2.7.15 h1:hysDXtdGZIRF5UZXwpfn3ZWRbm+ru4l53/ajBRGpCTw= +github.com/tdewolff/parse/v2 v2.7.15/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA= +github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE= +github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739 h1:IkjBCtQOOjIn03u/dMQK9g+Iw9ewps4mCl1nB8Sscbo= +github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8= +github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= +github.com/tidwall/gjson v1.17.3 h1:bwWLZU7icoKRG+C+0PNwIKC6FCJO/Q3p2pZvuP0jN94= +github.com/tidwall/gjson v1.17.3/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= +github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= +github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= +github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= +github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= +github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= +github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= +github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +github.com/twmb/franz-go v1.17.1 h1:0LwPsbbJeJ9R91DPUHSEd4su82WJWcTY1Zzbgbg4CeQ= +github.com/twmb/franz-go v1.17.1/go.mod h1:NreRdJ2F7dziDY/m6VyspWd6sNxHKXdMZI42UfQ3GXM= +github.com/twmb/franz-go/pkg/kadm v1.13.0 h1:bJq4C2ZikUE2jh/wl9MtMTQ/kpmnBgVFh8XMQBEC+60= +github.com/twmb/franz-go/pkg/kadm v1.13.0/go.mod h1:VMvpfjz/szpH9WB+vGM+rteTzVv0djyHFimci9qm2C0= +github.com/twmb/franz-go/pkg/kmsg v1.8.0 h1:lAQB9Z3aMrIP9qF9288XcFf/ccaSxEitNA1CDTEIeTA= +github.com/twmb/franz-go/pkg/kmsg v1.8.0/go.mod h1:HzYEb8G3uu5XevZbtU0dVbkphaKTHk0X68N5ka4q6mU= +github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= +github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= +github.com/urfave/cli v1.22.1 h1:+mkCCcOFKPnCmVYVcURKps1Xe+3zP90gSYGNfRkjoIY= +github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs= +github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo= +github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= +github.com/vektah/gqlparser/v2 v2.5.11 h1:JJxLtXIoN7+3x6MBdtIP59TP1RANnY7pXOaDnADQSf8= +github.com/vektah/gqlparser/v2 v2.5.11/go.mod h1:1rCcfwB2ekJofmluGWXMSEnPMZgbxzwj6FaZ/4OT8Cc= +github.com/vincent-petithory/dataurl v1.0.0 h1:cXw+kPto8NLuJtlMsI152irrVw9fRDX8AbShPRpg2CI= +github.com/vincent-petithory/dataurl v1.0.0/go.mod h1:FHafX5vmDzyP+1CQATJn7WFKc9CvnvxyvZy6I1MrG/U= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo= +github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= +github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= +github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/yuin/goldmark v1.7.1 h1:3bajkSilaCbjdKVsKdZjZCLBNPL9pYzrCakKaf4U49U= +github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E= +github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw= +github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.50.0 h1:cEPbyTSEHlQR89XVlyo78gqluF8Y3oMeBkXGWzQsfXY= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.50.0/go.mod h1:DKdbWcT4GH1D0Y3Sqt/PFXt2naRKDWtU+eE6oLdFNA8= +go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw= +go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0 h1:dIIDULZJpgdiHz5tXrTgKIMLkus6jEFa7x5SOKcyR7E= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0/go.mod h1:jlRVBe7+Z1wyxFSUs48L6OBQZ5JwH2Hg/Vbl+t9rAgI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.29.0 h1:JAv0Jwtl01UFiyWZEMiJZBiTlv5A50zNs8lsthXqIio= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.29.0/go.mod h1:QNKLmUEAq2QUbPQUfvw4fmv0bgbK7UlOSFCnXyfvSNc= +go.opentelemetry.io/otel/exporters/prometheus v0.51.0 h1:G7uexXb/K3T+T9fNLCCKncweEtNEBMTO+46hKX5EdKw= +go.opentelemetry.io/otel/exporters/prometheus v0.51.0/go.mod h1:v0mFe5Kk7woIh938mrZBJBmENYquyA0IICrlYm4Y0t4= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.29.0 h1:X3ZjNp36/WlkSYx0ul2jw4PtbNEDDeLskw3VPsrpYM0= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.29.0/go.mod h1:2uL/xnOXh0CHOBFCWXz5u1A4GXLiW+0IQIzVbeOEQ0U= +go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc= +go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8= +go.opentelemetry.io/otel/sdk v1.29.0 h1:vkqKjk7gwhS8VaWb0POZKmIEDimRCMsopNYnriHyryo= +go.opentelemetry.io/otel/sdk v1.29.0/go.mod h1:pM8Dx5WKnvxLCb+8lG1PRNIDxu9g9b9g59Qr7hfAAok= +go.opentelemetry.io/otel/sdk/metric v1.29.0 h1:K2CfmJohnRgvZ9UAj2/FhIf/okdWcNdBwe1m8xFXiSY= +go.opentelemetry.io/otel/sdk/metric v1.29.0/go.mod h1:6zZLdCl2fkauYoZIOn/soQIDSWFmNSRcICarHfuhNJQ= +go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4= +go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ= +go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0= +go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8= +go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= +go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= +golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M= +golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= +golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= +golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20210505214959-0714010a04ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= +golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= +golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= +golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8= +golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= +golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo= +golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= +golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= +golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= +golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= +golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= +golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk= +golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224= +golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.24.0 h1:J1shsA93PJUEVaUSaay7UXAyE8aimq3GW0pjlolpa24= +golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd h1:BBOTEWLuuEGQy9n1y9MhVJ9Qt0BDu21X8qZs71/uPZo= +google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd/go.mod h1:fO8wJzT2zbQbAjbIoos1285VfEIYKDDY+Dt+WpTkh6g= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd h1:6TEm2ZxXoQmFWFlt1vNxvVOa1Q0dXFQD1m/rYjXmS0E= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc= +google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= +google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8= +gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gorm.io/driver/postgres v1.5.9 h1:DkegyItji119OlcaLjqN11kHoUgZ/j13E0jkJZgD6A8= +gorm.io/driver/postgres v1.5.9/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI= +gorm.io/gorm v1.23.6/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk= +gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg= +gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= +gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo= +gotest.tools/v3 v3.3.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= +lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI= +lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k= +modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI= +modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4= +modernc.org/libc v1.55.3 h1:AzcW1mhlPNrRtjS5sS+eW2ISCgSOLLNyFzRh/V3Qj/U= +modernc.org/libc v1.55.3/go.mod h1:qFXepLhz+JjFThQ4kzwzOjA/y/artDeg+pcYnY+Q83w= +modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= +modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= +modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E= +modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU= +modernc.org/sqlite v1.32.0 h1:6BM4uGza7bWypsw4fdLRsLxut6bHe4c58VeqjRgST8s= +modernc.org/sqlite v1.32.0/go.mod h1:UqoylwmTb9F+IqXERT8bW9zzOWN8qwAIcLdzeBZs4hA= +modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA= +modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0= +modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= +modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= +moul.io/zapgorm2 v1.3.0 h1:+CzUTMIcnafd0d/BvBce8T4uPn6DQnpIrz64cyixlkk= +moul.io/zapgorm2 v1.3.0/go.mod h1:nPVy6U9goFKHR4s+zfSo1xVFaoU7Qgd5DoCdOfzoCqs= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= From 6de41ce58ada0a8820d09e5ee35e03146a78414f Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 17:42:08 +0800 Subject: [PATCH 07/19] fix: remove conflicted contract generation file and its use from worker.go --- go.sum | 18 + .../contract/polymarket/worker.go | 4 +- .../contract/polymarket/worker_test.go | 2 +- .../ethereum/contract/polymarket/contract.go | 2 +- .../polymarket/contract_condition_tokens.go | 2112 ---------- .../polymarket/contract_ctf_exchange.go | 3566 ----------------- .../contract_neg_risk_ctf_exchange.go | 3543 ---------------- 7 files changed, 22 insertions(+), 9225 deletions(-) delete mode 100644 provider/ethereum/contract/polymarket/contract_condition_tokens.go delete mode 100644 provider/ethereum/contract/polymarket/contract_ctf_exchange.go delete mode 100644 provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go diff --git a/go.sum b/go.sum index 8d414501..8faea3af 100644 --- a/go.sum +++ b/go.sum @@ -25,6 +25,8 @@ github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo github.com/andybalholm/cascadia v1.2.0/go.mod h1:YCyR8vOZT9aZ1CHEd8ap0gMVm2aFgxBp0T0eFw1RUQY= github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= +github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= +github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA= github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= @@ -104,6 +106,8 @@ github.com/ethereum/go-ethereum v1.13.15 h1:U7sSGYGo4SPjP6iNIifNoyIAiNjrmQkz6EwQ github.com/ethereum/go-ethereum v1.13.15/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/ferranbt/fastssz v0.1.2 h1:Dky6dXlngF6Qjc+EfDipAkE83N5I5DE68bY6O0VLNPk= +github.com/ferranbt/fastssz v0.1.2/go.mod h1:X5UPrE2u1UJjxHA8X54u04SBwdAQjG2sFtWs39YxyWs= github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA= github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= @@ -199,6 +203,8 @@ github.com/grafana/pyroscope-go v1.1.2 h1:7vCfdORYQMCxIzI3NlYAs3FcBP760+gWuYWOyi github.com/grafana/pyroscope-go v1.1.2/go.mod h1:HSSmHo2KRn6FasBA4vK7BMiQqyQq8KSuBKvrhkXxYPU= github.com/grafana/pyroscope-go/godeltaprof v0.1.8 h1:iwOtYXeeVSAeYefJNaxDytgjKtUuKQbJqgAIjlnicKg= github.com/grafana/pyroscope-go/godeltaprof v0.1.8/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= +github.com/graph-gophers/graphql-go v1.3.0 h1:Eb9x/q6MFpCLz7jBCiP/WTxjSDrYLR1QY41SORZyNJ0= +github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I= github.com/hamba/avro v1.8.0 h1:eCVrLX7UYThA3R3yBZ+rpmafA5qTc3ZjpTz6gYJoVGU= @@ -226,6 +232,12 @@ github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/influxdata/influxdb-client-go/v2 v2.13.0 h1:ioBbLmR5NMbAjP4UVA5r9b5xGjpABD7j65pI8kFphDM= +github.com/influxdata/influxdb-client-go/v2 v2.13.0/go.mod h1:k+spCbt9hcvqvUiz0sr5D8LolXHqAAOfPw9v/RIRHl4= +github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c h1:qSHzRbhzK8RdXOsAdfDgO49TtqC1oZ+acxPrkfTxcCs= +github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= +github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf h1:7JTmneyiNEwVBOHSjoMxiWAqB992atOeepeFYegn5RU= +github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= @@ -324,6 +336,8 @@ github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJm github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= +github.com/oapi-codegen/runtime v1.0.0 h1:P4rqFX5fMFWqRzY9M/3YF9+aPSPPB06IzP2P7oOxrWo= +github.com/oapi-codegen/runtime v1.0.0/go.mod h1:LmCUMQuPB4M/nLXilQXhHw+BLZdDb18B34OO356yJ/A= github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= @@ -345,12 +359,16 @@ github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQ github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss= github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8= +github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU= +github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/orlangure/gnomock v0.31.0 h1:dgjlQ8DYUPMyNwMZJuYBH+/GF+e7h3sloldPzIJF4k4= github.com/orlangure/gnomock v0.31.0/go.mod h1:RagxeYv3bKi+li9Lio2Faw5t6Mcy4akkeqXzkgAS3w0= github.com/ory/dockertest/v3 v3.10.0 h1:4K3z2VMe8Woe++invjaTB7VRyQXQy5UY+loujO4aNE4= github.com/ory/dockertest/v3 v3.10.0/go.mod h1:nr57ZbRWMqfsdGdFNLHz5jjNdDb7VVFnzAeW1n5N1Lg= github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= +github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM= +github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ= github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker.go b/internal/engine/worker/decentralized/contract/polymarket/worker.go index 558a3ed4..052d8031 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker.go @@ -31,7 +31,7 @@ type worker struct { ethereumClient ethereum.Client tokenClient token.Client ctfExchange *polymarket.CTFExchangeFilterer - negRiskCTF *polymarket.NegRiskCTFExchangeFilterer + //negRiskCTF *polymarket.NegRiskCTFExchangeFilterer } func (w *worker) Name() string { @@ -206,7 +206,7 @@ func (w *worker) buildMarketTradeAction(ctx context.Context, _ *source.Task, cha func NewWorker(config *config.Module) (engine.Worker, error) { instance := worker{ ctfExchange: lo.Must(polymarket.NewCTFExchangeFilterer(ethereum.AddressGenesis, nil)), - negRiskCTF: lo.Must(polymarket.NewNegRiskCTFExchangeFilterer(ethereum.AddressGenesis, nil)), + //negRiskCTF: lo.Must(polymarket.NewNegRiskCTFExchangeFilterer(ethereum.AddressGenesis, nil)), } var err error diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go index c31ec514..b3bb6f4d 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go @@ -38,7 +38,7 @@ func TestWorker_Polymarket(t *testing.T) { wantError require.ErrorAssertionFunc }{ { - name: "Test Prediction Offer Finalization (buy, sell actions)", + name: "Test Prediction Offer Match Finalization (buy, sell actions)", arguments: struct { task *source.Task config *config.Module diff --git a/provider/ethereum/contract/polymarket/contract.go b/provider/ethereum/contract/polymarket/contract.go index fe5a296e..fea1d8de 100644 --- a/provider/ethereum/contract/polymarket/contract.go +++ b/provider/ethereum/contract/polymarket/contract.go @@ -10,7 +10,7 @@ import ( //go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/CTFExchange.abi --pkg polymarket --type CTFExchange --out contract_ctf_exchange.go // Neg Risk CTF Exchange // https://polygonscan.com/address/0xc5d563a36ae78145c45a50134d48a1215220f80a -//go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/NegRiskCTFExchange.abi --pkg polymarket --type NegRiskCTFExchange --out contract_neg_risk_ctf_exchange.go +// go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/NegRiskCTFExchange.abi --pkg polymarket --type NegRiskCTFExchange --out contract_neg_risk_ctf_exchange.go // Condition Tokens // https://polygonscan.com/address/0x4D97DCd97eC945f40cF65F87097ACe5EA0476045 //go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/ConditionTokens.abi --pkg polymarket --type ConditionTokens --out contract_condition_tokens.go diff --git a/provider/ethereum/contract/polymarket/contract_condition_tokens.go b/provider/ethereum/contract/polymarket/contract_condition_tokens.go deleted file mode 100644 index b391d33e..00000000 --- a/provider/ethereum/contract/polymarket/contract_condition_tokens.go +++ /dev/null @@ -1,2112 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package polymarket - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// ConditionTokensMetaData contains all meta data concerning the ConditionTokens contract. -var ConditionTokensMetaData = &bind.MetaData{ - ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"indexSets\",\"type\":\"uint256[]\"}],\"name\":\"redeemPositions\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\"},{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"payoutNumerators\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"ids\",\"type\":\"uint256[]\"},{\"name\":\"values\",\"type\":\"uint256[]\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeBatchTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"collectionId\",\"type\":\"bytes32\"}],\"name\":\"getPositionId\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owners\",\"type\":\"address[]\"},{\"name\":\"ids\",\"type\":\"uint256[]\"}],\"name\":\"balanceOfBatch\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"partition\",\"type\":\"uint256[]\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"splitPosition\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"oracle\",\"type\":\"address\"},{\"name\":\"questionId\",\"type\":\"bytes32\"},{\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"indexSet\",\"type\":\"uint256\"}],\"name\":\"getCollectionId\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"partition\",\"type\":\"uint256[]\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mergePositions\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"questionId\",\"type\":\"bytes32\"},{\"name\":\"payouts\",\"type\":\"uint256[]\"}],\"name\":\"reportPayouts\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"getOutcomeSlotCount\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"oracle\",\"type\":\"address\"},{\"name\":\"questionId\",\"type\":\"bytes32\"},{\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"}],\"name\":\"prepareCondition\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"payoutDenominator\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"id\",\"type\":\"uint256\"},{\"name\":\"value\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"oracle\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"questionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"}],\"name\":\"ConditionPreparation\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"oracle\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"questionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"payoutNumerators\",\"type\":\"uint256[]\"}],\"name\":\"ConditionResolution\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"stakeholder\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"collateralToken\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"partition\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"PositionSplit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"stakeholder\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"collateralToken\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"partition\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"PositionsMerge\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"redeemer\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"collateralToken\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"indexSets\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"payout\",\"type\":\"uint256\"}],\"name\":\"PayoutRedemption\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"id\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"TransferSingle\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"ids\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"values\",\"type\":\"uint256[]\"}],\"name\":\"TransferBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"value\",\"type\":\"string\"},{\"indexed\":true,\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"URI\",\"type\":\"event\"}]", -} - -// ConditionTokensABI is the input ABI used to generate the binding from. -// Deprecated: Use ConditionTokensMetaData.ABI instead. -var ConditionTokensABI = ConditionTokensMetaData.ABI - -// ConditionTokens is an auto generated Go binding around an Ethereum contract. -type ConditionTokens struct { - ConditionTokensCaller // Read-only binding to the contract - ConditionTokensTransactor // Write-only binding to the contract - ConditionTokensFilterer // Log filterer for contract events -} - -// ConditionTokensCaller is an auto generated read-only Go binding around an Ethereum contract. -type ConditionTokensCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ConditionTokensTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ConditionTokensTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ConditionTokensFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ConditionTokensFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ConditionTokensSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ConditionTokensSession struct { - Contract *ConditionTokens // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ConditionTokensCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ConditionTokensCallerSession struct { - Contract *ConditionTokensCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ConditionTokensTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ConditionTokensTransactorSession struct { - Contract *ConditionTokensTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ConditionTokensRaw is an auto generated low-level Go binding around an Ethereum contract. -type ConditionTokensRaw struct { - Contract *ConditionTokens // Generic contract binding to access the raw methods on -} - -// ConditionTokensCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ConditionTokensCallerRaw struct { - Contract *ConditionTokensCaller // Generic read-only contract binding to access the raw methods on -} - -// ConditionTokensTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ConditionTokensTransactorRaw struct { - Contract *ConditionTokensTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewConditionTokens creates a new instance of ConditionTokens, bound to a specific deployed contract. -func NewConditionTokens(address common.Address, backend bind.ContractBackend) (*ConditionTokens, error) { - contract, err := bindConditionTokens(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ConditionTokens{ConditionTokensCaller: ConditionTokensCaller{contract: contract}, ConditionTokensTransactor: ConditionTokensTransactor{contract: contract}, ConditionTokensFilterer: ConditionTokensFilterer{contract: contract}}, nil -} - -// NewConditionTokensCaller creates a new read-only instance of ConditionTokens, bound to a specific deployed contract. -func NewConditionTokensCaller(address common.Address, caller bind.ContractCaller) (*ConditionTokensCaller, error) { - contract, err := bindConditionTokens(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ConditionTokensCaller{contract: contract}, nil -} - -// NewConditionTokensTransactor creates a new write-only instance of ConditionTokens, bound to a specific deployed contract. -func NewConditionTokensTransactor(address common.Address, transactor bind.ContractTransactor) (*ConditionTokensTransactor, error) { - contract, err := bindConditionTokens(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ConditionTokensTransactor{contract: contract}, nil -} - -// NewConditionTokensFilterer creates a new log filterer instance of ConditionTokens, bound to a specific deployed contract. -func NewConditionTokensFilterer(address common.Address, filterer bind.ContractFilterer) (*ConditionTokensFilterer, error) { - contract, err := bindConditionTokens(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ConditionTokensFilterer{contract: contract}, nil -} - -// bindConditionTokens binds a generic wrapper to an already deployed contract. -func bindConditionTokens(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ConditionTokensMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ConditionTokens *ConditionTokensRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ConditionTokens.Contract.ConditionTokensCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ConditionTokens *ConditionTokensRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ConditionTokens.Contract.ConditionTokensTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ConditionTokens *ConditionTokensRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ConditionTokens.Contract.ConditionTokensTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ConditionTokens *ConditionTokensCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ConditionTokens.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ConditionTokens *ConditionTokensTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ConditionTokens.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ConditionTokens *ConditionTokensTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ConditionTokens.Contract.contract.Transact(opts, method, params...) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e. -// -// Solidity: function balanceOf(address owner, uint256 id) view returns(uint256) -func (_ConditionTokens *ConditionTokensCaller) BalanceOf(opts *bind.CallOpts, owner common.Address, id *big.Int) (*big.Int, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "balanceOf", owner, id) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e. -// -// Solidity: function balanceOf(address owner, uint256 id) view returns(uint256) -func (_ConditionTokens *ConditionTokensSession) BalanceOf(owner common.Address, id *big.Int) (*big.Int, error) { - return _ConditionTokens.Contract.BalanceOf(&_ConditionTokens.CallOpts, owner, id) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e. -// -// Solidity: function balanceOf(address owner, uint256 id) view returns(uint256) -func (_ConditionTokens *ConditionTokensCallerSession) BalanceOf(owner common.Address, id *big.Int) (*big.Int, error) { - return _ConditionTokens.Contract.BalanceOf(&_ConditionTokens.CallOpts, owner, id) -} - -// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4. -// -// Solidity: function balanceOfBatch(address[] owners, uint256[] ids) view returns(uint256[]) -func (_ConditionTokens *ConditionTokensCaller) BalanceOfBatch(opts *bind.CallOpts, owners []common.Address, ids []*big.Int) ([]*big.Int, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "balanceOfBatch", owners, ids) - - if err != nil { - return *new([]*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) - - return out0, err - -} - -// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4. -// -// Solidity: function balanceOfBatch(address[] owners, uint256[] ids) view returns(uint256[]) -func (_ConditionTokens *ConditionTokensSession) BalanceOfBatch(owners []common.Address, ids []*big.Int) ([]*big.Int, error) { - return _ConditionTokens.Contract.BalanceOfBatch(&_ConditionTokens.CallOpts, owners, ids) -} - -// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4. -// -// Solidity: function balanceOfBatch(address[] owners, uint256[] ids) view returns(uint256[]) -func (_ConditionTokens *ConditionTokensCallerSession) BalanceOfBatch(owners []common.Address, ids []*big.Int) ([]*big.Int, error) { - return _ConditionTokens.Contract.BalanceOfBatch(&_ConditionTokens.CallOpts, owners, ids) -} - -// GetCollectionId is a free data retrieval call binding the contract method 0x856296f7. -// -// Solidity: function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) view returns(bytes32) -func (_ConditionTokens *ConditionTokensCaller) GetCollectionId(opts *bind.CallOpts, parentCollectionId [32]byte, conditionId [32]byte, indexSet *big.Int) ([32]byte, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "getCollectionId", parentCollectionId, conditionId, indexSet) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// GetCollectionId is a free data retrieval call binding the contract method 0x856296f7. -// -// Solidity: function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) view returns(bytes32) -func (_ConditionTokens *ConditionTokensSession) GetCollectionId(parentCollectionId [32]byte, conditionId [32]byte, indexSet *big.Int) ([32]byte, error) { - return _ConditionTokens.Contract.GetCollectionId(&_ConditionTokens.CallOpts, parentCollectionId, conditionId, indexSet) -} - -// GetCollectionId is a free data retrieval call binding the contract method 0x856296f7. -// -// Solidity: function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) view returns(bytes32) -func (_ConditionTokens *ConditionTokensCallerSession) GetCollectionId(parentCollectionId [32]byte, conditionId [32]byte, indexSet *big.Int) ([32]byte, error) { - return _ConditionTokens.Contract.GetCollectionId(&_ConditionTokens.CallOpts, parentCollectionId, conditionId, indexSet) -} - -// GetConditionId is a free data retrieval call binding the contract method 0x852c6ae2. -// -// Solidity: function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) pure returns(bytes32) -func (_ConditionTokens *ConditionTokensCaller) GetConditionId(opts *bind.CallOpts, oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) ([32]byte, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "getConditionId", oracle, questionId, outcomeSlotCount) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// GetConditionId is a free data retrieval call binding the contract method 0x852c6ae2. -// -// Solidity: function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) pure returns(bytes32) -func (_ConditionTokens *ConditionTokensSession) GetConditionId(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) ([32]byte, error) { - return _ConditionTokens.Contract.GetConditionId(&_ConditionTokens.CallOpts, oracle, questionId, outcomeSlotCount) -} - -// GetConditionId is a free data retrieval call binding the contract method 0x852c6ae2. -// -// Solidity: function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) pure returns(bytes32) -func (_ConditionTokens *ConditionTokensCallerSession) GetConditionId(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) ([32]byte, error) { - return _ConditionTokens.Contract.GetConditionId(&_ConditionTokens.CallOpts, oracle, questionId, outcomeSlotCount) -} - -// GetOutcomeSlotCount is a free data retrieval call binding the contract method 0xd42dc0c2. -// -// Solidity: function getOutcomeSlotCount(bytes32 conditionId) view returns(uint256) -func (_ConditionTokens *ConditionTokensCaller) GetOutcomeSlotCount(opts *bind.CallOpts, conditionId [32]byte) (*big.Int, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "getOutcomeSlotCount", conditionId) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// GetOutcomeSlotCount is a free data retrieval call binding the contract method 0xd42dc0c2. -// -// Solidity: function getOutcomeSlotCount(bytes32 conditionId) view returns(uint256) -func (_ConditionTokens *ConditionTokensSession) GetOutcomeSlotCount(conditionId [32]byte) (*big.Int, error) { - return _ConditionTokens.Contract.GetOutcomeSlotCount(&_ConditionTokens.CallOpts, conditionId) -} - -// GetOutcomeSlotCount is a free data retrieval call binding the contract method 0xd42dc0c2. -// -// Solidity: function getOutcomeSlotCount(bytes32 conditionId) view returns(uint256) -func (_ConditionTokens *ConditionTokensCallerSession) GetOutcomeSlotCount(conditionId [32]byte) (*big.Int, error) { - return _ConditionTokens.Contract.GetOutcomeSlotCount(&_ConditionTokens.CallOpts, conditionId) -} - -// GetPositionId is a free data retrieval call binding the contract method 0x39dd7530. -// -// Solidity: function getPositionId(address collateralToken, bytes32 collectionId) pure returns(uint256) -func (_ConditionTokens *ConditionTokensCaller) GetPositionId(opts *bind.CallOpts, collateralToken common.Address, collectionId [32]byte) (*big.Int, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "getPositionId", collateralToken, collectionId) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// GetPositionId is a free data retrieval call binding the contract method 0x39dd7530. -// -// Solidity: function getPositionId(address collateralToken, bytes32 collectionId) pure returns(uint256) -func (_ConditionTokens *ConditionTokensSession) GetPositionId(collateralToken common.Address, collectionId [32]byte) (*big.Int, error) { - return _ConditionTokens.Contract.GetPositionId(&_ConditionTokens.CallOpts, collateralToken, collectionId) -} - -// GetPositionId is a free data retrieval call binding the contract method 0x39dd7530. -// -// Solidity: function getPositionId(address collateralToken, bytes32 collectionId) pure returns(uint256) -func (_ConditionTokens *ConditionTokensCallerSession) GetPositionId(collateralToken common.Address, collectionId [32]byte) (*big.Int, error) { - return _ConditionTokens.Contract.GetPositionId(&_ConditionTokens.CallOpts, collateralToken, collectionId) -} - -// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. -// -// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) -func (_ConditionTokens *ConditionTokensCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "isApprovedForAll", owner, operator) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. -// -// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) -func (_ConditionTokens *ConditionTokensSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) { - return _ConditionTokens.Contract.IsApprovedForAll(&_ConditionTokens.CallOpts, owner, operator) -} - -// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. -// -// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) -func (_ConditionTokens *ConditionTokensCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) { - return _ConditionTokens.Contract.IsApprovedForAll(&_ConditionTokens.CallOpts, owner, operator) -} - -// PayoutDenominator is a free data retrieval call binding the contract method 0xdd34de67. -// -// Solidity: function payoutDenominator(bytes32 ) view returns(uint256) -func (_ConditionTokens *ConditionTokensCaller) PayoutDenominator(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "payoutDenominator", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// PayoutDenominator is a free data retrieval call binding the contract method 0xdd34de67. -// -// Solidity: function payoutDenominator(bytes32 ) view returns(uint256) -func (_ConditionTokens *ConditionTokensSession) PayoutDenominator(arg0 [32]byte) (*big.Int, error) { - return _ConditionTokens.Contract.PayoutDenominator(&_ConditionTokens.CallOpts, arg0) -} - -// PayoutDenominator is a free data retrieval call binding the contract method 0xdd34de67. -// -// Solidity: function payoutDenominator(bytes32 ) view returns(uint256) -func (_ConditionTokens *ConditionTokensCallerSession) PayoutDenominator(arg0 [32]byte) (*big.Int, error) { - return _ConditionTokens.Contract.PayoutDenominator(&_ConditionTokens.CallOpts, arg0) -} - -// PayoutNumerators is a free data retrieval call binding the contract method 0x0504c814. -// -// Solidity: function payoutNumerators(bytes32 , uint256 ) view returns(uint256) -func (_ConditionTokens *ConditionTokensCaller) PayoutNumerators(opts *bind.CallOpts, arg0 [32]byte, arg1 *big.Int) (*big.Int, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "payoutNumerators", arg0, arg1) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// PayoutNumerators is a free data retrieval call binding the contract method 0x0504c814. -// -// Solidity: function payoutNumerators(bytes32 , uint256 ) view returns(uint256) -func (_ConditionTokens *ConditionTokensSession) PayoutNumerators(arg0 [32]byte, arg1 *big.Int) (*big.Int, error) { - return _ConditionTokens.Contract.PayoutNumerators(&_ConditionTokens.CallOpts, arg0, arg1) -} - -// PayoutNumerators is a free data retrieval call binding the contract method 0x0504c814. -// -// Solidity: function payoutNumerators(bytes32 , uint256 ) view returns(uint256) -func (_ConditionTokens *ConditionTokensCallerSession) PayoutNumerators(arg0 [32]byte, arg1 *big.Int) (*big.Int, error) { - return _ConditionTokens.Contract.PayoutNumerators(&_ConditionTokens.CallOpts, arg0, arg1) -} - -// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. -// -// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) -func (_ConditionTokens *ConditionTokensCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { - var out []interface{} - err := _ConditionTokens.contract.Call(opts, &out, "supportsInterface", interfaceId) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. -// -// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) -func (_ConditionTokens *ConditionTokensSession) SupportsInterface(interfaceId [4]byte) (bool, error) { - return _ConditionTokens.Contract.SupportsInterface(&_ConditionTokens.CallOpts, interfaceId) -} - -// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. -// -// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) -func (_ConditionTokens *ConditionTokensCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { - return _ConditionTokens.Contract.SupportsInterface(&_ConditionTokens.CallOpts, interfaceId) -} - -// MergePositions is a paid mutator transaction binding the contract method 0x9e7212ad. -// -// Solidity: function mergePositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() -func (_ConditionTokens *ConditionTokensTransactor) MergePositions(opts *bind.TransactOpts, collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { - return _ConditionTokens.contract.Transact(opts, "mergePositions", collateralToken, parentCollectionId, conditionId, partition, amount) -} - -// MergePositions is a paid mutator transaction binding the contract method 0x9e7212ad. -// -// Solidity: function mergePositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() -func (_ConditionTokens *ConditionTokensSession) MergePositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.MergePositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) -} - -// MergePositions is a paid mutator transaction binding the contract method 0x9e7212ad. -// -// Solidity: function mergePositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() -func (_ConditionTokens *ConditionTokensTransactorSession) MergePositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.MergePositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) -} - -// PrepareCondition is a paid mutator transaction binding the contract method 0xd96ee754. -// -// Solidity: function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) returns() -func (_ConditionTokens *ConditionTokensTransactor) PrepareCondition(opts *bind.TransactOpts, oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) (*types.Transaction, error) { - return _ConditionTokens.contract.Transact(opts, "prepareCondition", oracle, questionId, outcomeSlotCount) -} - -// PrepareCondition is a paid mutator transaction binding the contract method 0xd96ee754. -// -// Solidity: function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) returns() -func (_ConditionTokens *ConditionTokensSession) PrepareCondition(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.PrepareCondition(&_ConditionTokens.TransactOpts, oracle, questionId, outcomeSlotCount) -} - -// PrepareCondition is a paid mutator transaction binding the contract method 0xd96ee754. -// -// Solidity: function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) returns() -func (_ConditionTokens *ConditionTokensTransactorSession) PrepareCondition(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.PrepareCondition(&_ConditionTokens.TransactOpts, oracle, questionId, outcomeSlotCount) -} - -// RedeemPositions is a paid mutator transaction binding the contract method 0x01b7037c. -// -// Solidity: function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) returns() -func (_ConditionTokens *ConditionTokensTransactor) RedeemPositions(opts *bind.TransactOpts, collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, indexSets []*big.Int) (*types.Transaction, error) { - return _ConditionTokens.contract.Transact(opts, "redeemPositions", collateralToken, parentCollectionId, conditionId, indexSets) -} - -// RedeemPositions is a paid mutator transaction binding the contract method 0x01b7037c. -// -// Solidity: function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) returns() -func (_ConditionTokens *ConditionTokensSession) RedeemPositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, indexSets []*big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.RedeemPositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, indexSets) -} - -// RedeemPositions is a paid mutator transaction binding the contract method 0x01b7037c. -// -// Solidity: function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) returns() -func (_ConditionTokens *ConditionTokensTransactorSession) RedeemPositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, indexSets []*big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.RedeemPositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, indexSets) -} - -// ReportPayouts is a paid mutator transaction binding the contract method 0xc49298ac. -// -// Solidity: function reportPayouts(bytes32 questionId, uint256[] payouts) returns() -func (_ConditionTokens *ConditionTokensTransactor) ReportPayouts(opts *bind.TransactOpts, questionId [32]byte, payouts []*big.Int) (*types.Transaction, error) { - return _ConditionTokens.contract.Transact(opts, "reportPayouts", questionId, payouts) -} - -// ReportPayouts is a paid mutator transaction binding the contract method 0xc49298ac. -// -// Solidity: function reportPayouts(bytes32 questionId, uint256[] payouts) returns() -func (_ConditionTokens *ConditionTokensSession) ReportPayouts(questionId [32]byte, payouts []*big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.ReportPayouts(&_ConditionTokens.TransactOpts, questionId, payouts) -} - -// ReportPayouts is a paid mutator transaction binding the contract method 0xc49298ac. -// -// Solidity: function reportPayouts(bytes32 questionId, uint256[] payouts) returns() -func (_ConditionTokens *ConditionTokensTransactorSession) ReportPayouts(questionId [32]byte, payouts []*big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.ReportPayouts(&_ConditionTokens.TransactOpts, questionId, payouts) -} - -// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6. -// -// Solidity: function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] values, bytes data) returns() -func (_ConditionTokens *ConditionTokensTransactor) SafeBatchTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ids []*big.Int, values []*big.Int, data []byte) (*types.Transaction, error) { - return _ConditionTokens.contract.Transact(opts, "safeBatchTransferFrom", from, to, ids, values, data) -} - -// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6. -// -// Solidity: function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] values, bytes data) returns() -func (_ConditionTokens *ConditionTokensSession) SafeBatchTransferFrom(from common.Address, to common.Address, ids []*big.Int, values []*big.Int, data []byte) (*types.Transaction, error) { - return _ConditionTokens.Contract.SafeBatchTransferFrom(&_ConditionTokens.TransactOpts, from, to, ids, values, data) -} - -// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6. -// -// Solidity: function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] values, bytes data) returns() -func (_ConditionTokens *ConditionTokensTransactorSession) SafeBatchTransferFrom(from common.Address, to common.Address, ids []*big.Int, values []*big.Int, data []byte) (*types.Transaction, error) { - return _ConditionTokens.Contract.SafeBatchTransferFrom(&_ConditionTokens.TransactOpts, from, to, ids, values, data) -} - -// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a. -// -// Solidity: function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes data) returns() -func (_ConditionTokens *ConditionTokensTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, id *big.Int, value *big.Int, data []byte) (*types.Transaction, error) { - return _ConditionTokens.contract.Transact(opts, "safeTransferFrom", from, to, id, value, data) -} - -// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a. -// -// Solidity: function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes data) returns() -func (_ConditionTokens *ConditionTokensSession) SafeTransferFrom(from common.Address, to common.Address, id *big.Int, value *big.Int, data []byte) (*types.Transaction, error) { - return _ConditionTokens.Contract.SafeTransferFrom(&_ConditionTokens.TransactOpts, from, to, id, value, data) -} - -// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a. -// -// Solidity: function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes data) returns() -func (_ConditionTokens *ConditionTokensTransactorSession) SafeTransferFrom(from common.Address, to common.Address, id *big.Int, value *big.Int, data []byte) (*types.Transaction, error) { - return _ConditionTokens.Contract.SafeTransferFrom(&_ConditionTokens.TransactOpts, from, to, id, value, data) -} - -// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. -// -// Solidity: function setApprovalForAll(address operator, bool approved) returns() -func (_ConditionTokens *ConditionTokensTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, approved bool) (*types.Transaction, error) { - return _ConditionTokens.contract.Transact(opts, "setApprovalForAll", operator, approved) -} - -// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. -// -// Solidity: function setApprovalForAll(address operator, bool approved) returns() -func (_ConditionTokens *ConditionTokensSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) { - return _ConditionTokens.Contract.SetApprovalForAll(&_ConditionTokens.TransactOpts, operator, approved) -} - -// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. -// -// Solidity: function setApprovalForAll(address operator, bool approved) returns() -func (_ConditionTokens *ConditionTokensTransactorSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) { - return _ConditionTokens.Contract.SetApprovalForAll(&_ConditionTokens.TransactOpts, operator, approved) -} - -// SplitPosition is a paid mutator transaction binding the contract method 0x72ce4275. -// -// Solidity: function splitPosition(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() -func (_ConditionTokens *ConditionTokensTransactor) SplitPosition(opts *bind.TransactOpts, collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { - return _ConditionTokens.contract.Transact(opts, "splitPosition", collateralToken, parentCollectionId, conditionId, partition, amount) -} - -// SplitPosition is a paid mutator transaction binding the contract method 0x72ce4275. -// -// Solidity: function splitPosition(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() -func (_ConditionTokens *ConditionTokensSession) SplitPosition(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.SplitPosition(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) -} - -// SplitPosition is a paid mutator transaction binding the contract method 0x72ce4275. -// -// Solidity: function splitPosition(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() -func (_ConditionTokens *ConditionTokensTransactorSession) SplitPosition(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { - return _ConditionTokens.Contract.SplitPosition(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) -} - -// ConditionTokensApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ConditionTokens contract. -type ConditionTokensApprovalForAllIterator struct { - Event *ConditionTokensApprovalForAll // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ConditionTokensApprovalForAllIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ConditionTokensApprovalForAll) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ConditionTokensApprovalForAll) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ConditionTokensApprovalForAllIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ConditionTokensApprovalForAllIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ConditionTokensApprovalForAll represents a ApprovalForAll event raised by the ConditionTokens contract. -type ConditionTokensApprovalForAll struct { - Owner common.Address - Operator common.Address - Approved bool - Raw types.Log // Blockchain specific contextual infos -} - -// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. -// -// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved) -func (_ConditionTokens *ConditionTokensFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ConditionTokensApprovalForAllIterator, error) { - - var ownerRule []interface{} - for _, ownerItem := range owner { - ownerRule = append(ownerRule, ownerItem) - } - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule) - if err != nil { - return nil, err - } - return &ConditionTokensApprovalForAllIterator{contract: _ConditionTokens.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil -} - -// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. -// -// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved) -func (_ConditionTokens *ConditionTokensFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ConditionTokensApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) { - - var ownerRule []interface{} - for _, ownerItem := range owner { - ownerRule = append(ownerRule, ownerItem) - } - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ConditionTokensApprovalForAll) - if err := _ConditionTokens.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. -// -// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved) -func (_ConditionTokens *ConditionTokensFilterer) ParseApprovalForAll(log types.Log) (*ConditionTokensApprovalForAll, error) { - event := new(ConditionTokensApprovalForAll) - if err := _ConditionTokens.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ConditionTokensConditionPreparationIterator is returned from FilterConditionPreparation and is used to iterate over the raw logs and unpacked data for ConditionPreparation events raised by the ConditionTokens contract. -type ConditionTokensConditionPreparationIterator struct { - Event *ConditionTokensConditionPreparation // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ConditionTokensConditionPreparationIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ConditionTokensConditionPreparation) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ConditionTokensConditionPreparation) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ConditionTokensConditionPreparationIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ConditionTokensConditionPreparationIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ConditionTokensConditionPreparation represents a ConditionPreparation event raised by the ConditionTokens contract. -type ConditionTokensConditionPreparation struct { - ConditionId [32]byte - Oracle common.Address - QuestionId [32]byte - OutcomeSlotCount *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterConditionPreparation is a free log retrieval operation binding the contract event 0xab3760c3bd2bb38b5bcf54dc79802ed67338b4cf29f3054ded67ed24661e4177. -// -// Solidity: event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount) -func (_ConditionTokens *ConditionTokensFilterer) FilterConditionPreparation(opts *bind.FilterOpts, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (*ConditionTokensConditionPreparationIterator, error) { - - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - var oracleRule []interface{} - for _, oracleItem := range oracle { - oracleRule = append(oracleRule, oracleItem) - } - var questionIdRule []interface{} - for _, questionIdItem := range questionId { - questionIdRule = append(questionIdRule, questionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "ConditionPreparation", conditionIdRule, oracleRule, questionIdRule) - if err != nil { - return nil, err - } - return &ConditionTokensConditionPreparationIterator{contract: _ConditionTokens.contract, event: "ConditionPreparation", logs: logs, sub: sub}, nil -} - -// WatchConditionPreparation is a free log subscription operation binding the contract event 0xab3760c3bd2bb38b5bcf54dc79802ed67338b4cf29f3054ded67ed24661e4177. -// -// Solidity: event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount) -func (_ConditionTokens *ConditionTokensFilterer) WatchConditionPreparation(opts *bind.WatchOpts, sink chan<- *ConditionTokensConditionPreparation, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (event.Subscription, error) { - - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - var oracleRule []interface{} - for _, oracleItem := range oracle { - oracleRule = append(oracleRule, oracleItem) - } - var questionIdRule []interface{} - for _, questionIdItem := range questionId { - questionIdRule = append(questionIdRule, questionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "ConditionPreparation", conditionIdRule, oracleRule, questionIdRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ConditionTokensConditionPreparation) - if err := _ConditionTokens.contract.UnpackLog(event, "ConditionPreparation", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseConditionPreparation is a log parse operation binding the contract event 0xab3760c3bd2bb38b5bcf54dc79802ed67338b4cf29f3054ded67ed24661e4177. -// -// Solidity: event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount) -func (_ConditionTokens *ConditionTokensFilterer) ParseConditionPreparation(log types.Log) (*ConditionTokensConditionPreparation, error) { - event := new(ConditionTokensConditionPreparation) - if err := _ConditionTokens.contract.UnpackLog(event, "ConditionPreparation", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ConditionTokensConditionResolutionIterator is returned from FilterConditionResolution and is used to iterate over the raw logs and unpacked data for ConditionResolution events raised by the ConditionTokens contract. -type ConditionTokensConditionResolutionIterator struct { - Event *ConditionTokensConditionResolution // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ConditionTokensConditionResolutionIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ConditionTokensConditionResolution) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ConditionTokensConditionResolution) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ConditionTokensConditionResolutionIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ConditionTokensConditionResolutionIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ConditionTokensConditionResolution represents a ConditionResolution event raised by the ConditionTokens contract. -type ConditionTokensConditionResolution struct { - ConditionId [32]byte - Oracle common.Address - QuestionId [32]byte - OutcomeSlotCount *big.Int - PayoutNumerators []*big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterConditionResolution is a free log retrieval operation binding the contract event 0xb44d84d3289691f71497564b85d4233648d9dbae8cbdbb4329f301c3a0185894. -// -// Solidity: event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators) -func (_ConditionTokens *ConditionTokensFilterer) FilterConditionResolution(opts *bind.FilterOpts, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (*ConditionTokensConditionResolutionIterator, error) { - - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - var oracleRule []interface{} - for _, oracleItem := range oracle { - oracleRule = append(oracleRule, oracleItem) - } - var questionIdRule []interface{} - for _, questionIdItem := range questionId { - questionIdRule = append(questionIdRule, questionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "ConditionResolution", conditionIdRule, oracleRule, questionIdRule) - if err != nil { - return nil, err - } - return &ConditionTokensConditionResolutionIterator{contract: _ConditionTokens.contract, event: "ConditionResolution", logs: logs, sub: sub}, nil -} - -// WatchConditionResolution is a free log subscription operation binding the contract event 0xb44d84d3289691f71497564b85d4233648d9dbae8cbdbb4329f301c3a0185894. -// -// Solidity: event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators) -func (_ConditionTokens *ConditionTokensFilterer) WatchConditionResolution(opts *bind.WatchOpts, sink chan<- *ConditionTokensConditionResolution, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (event.Subscription, error) { - - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - var oracleRule []interface{} - for _, oracleItem := range oracle { - oracleRule = append(oracleRule, oracleItem) - } - var questionIdRule []interface{} - for _, questionIdItem := range questionId { - questionIdRule = append(questionIdRule, questionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "ConditionResolution", conditionIdRule, oracleRule, questionIdRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ConditionTokensConditionResolution) - if err := _ConditionTokens.contract.UnpackLog(event, "ConditionResolution", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseConditionResolution is a log parse operation binding the contract event 0xb44d84d3289691f71497564b85d4233648d9dbae8cbdbb4329f301c3a0185894. -// -// Solidity: event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators) -func (_ConditionTokens *ConditionTokensFilterer) ParseConditionResolution(log types.Log) (*ConditionTokensConditionResolution, error) { - event := new(ConditionTokensConditionResolution) - if err := _ConditionTokens.contract.UnpackLog(event, "ConditionResolution", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ConditionTokensPayoutRedemptionIterator is returned from FilterPayoutRedemption and is used to iterate over the raw logs and unpacked data for PayoutRedemption events raised by the ConditionTokens contract. -type ConditionTokensPayoutRedemptionIterator struct { - Event *ConditionTokensPayoutRedemption // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ConditionTokensPayoutRedemptionIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ConditionTokensPayoutRedemption) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ConditionTokensPayoutRedemption) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ConditionTokensPayoutRedemptionIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ConditionTokensPayoutRedemptionIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ConditionTokensPayoutRedemption represents a PayoutRedemption event raised by the ConditionTokens contract. -type ConditionTokensPayoutRedemption struct { - Redeemer common.Address - CollateralToken common.Address - ParentCollectionId [32]byte - ConditionId [32]byte - IndexSets []*big.Int - Payout *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterPayoutRedemption is a free log retrieval operation binding the contract event 0x2682012a4a4f1973119f1c9b90745d1bd91fa2bab387344f044cb3586864d18d. -// -// Solidity: event PayoutRedemption(address indexed redeemer, address indexed collateralToken, bytes32 indexed parentCollectionId, bytes32 conditionId, uint256[] indexSets, uint256 payout) -func (_ConditionTokens *ConditionTokensFilterer) FilterPayoutRedemption(opts *bind.FilterOpts, redeemer []common.Address, collateralToken []common.Address, parentCollectionId [][32]byte) (*ConditionTokensPayoutRedemptionIterator, error) { - - var redeemerRule []interface{} - for _, redeemerItem := range redeemer { - redeemerRule = append(redeemerRule, redeemerItem) - } - var collateralTokenRule []interface{} - for _, collateralTokenItem := range collateralToken { - collateralTokenRule = append(collateralTokenRule, collateralTokenItem) - } - var parentCollectionIdRule []interface{} - for _, parentCollectionIdItem := range parentCollectionId { - parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "PayoutRedemption", redeemerRule, collateralTokenRule, parentCollectionIdRule) - if err != nil { - return nil, err - } - return &ConditionTokensPayoutRedemptionIterator{contract: _ConditionTokens.contract, event: "PayoutRedemption", logs: logs, sub: sub}, nil -} - -// WatchPayoutRedemption is a free log subscription operation binding the contract event 0x2682012a4a4f1973119f1c9b90745d1bd91fa2bab387344f044cb3586864d18d. -// -// Solidity: event PayoutRedemption(address indexed redeemer, address indexed collateralToken, bytes32 indexed parentCollectionId, bytes32 conditionId, uint256[] indexSets, uint256 payout) -func (_ConditionTokens *ConditionTokensFilterer) WatchPayoutRedemption(opts *bind.WatchOpts, sink chan<- *ConditionTokensPayoutRedemption, redeemer []common.Address, collateralToken []common.Address, parentCollectionId [][32]byte) (event.Subscription, error) { - - var redeemerRule []interface{} - for _, redeemerItem := range redeemer { - redeemerRule = append(redeemerRule, redeemerItem) - } - var collateralTokenRule []interface{} - for _, collateralTokenItem := range collateralToken { - collateralTokenRule = append(collateralTokenRule, collateralTokenItem) - } - var parentCollectionIdRule []interface{} - for _, parentCollectionIdItem := range parentCollectionId { - parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "PayoutRedemption", redeemerRule, collateralTokenRule, parentCollectionIdRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ConditionTokensPayoutRedemption) - if err := _ConditionTokens.contract.UnpackLog(event, "PayoutRedemption", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParsePayoutRedemption is a log parse operation binding the contract event 0x2682012a4a4f1973119f1c9b90745d1bd91fa2bab387344f044cb3586864d18d. -// -// Solidity: event PayoutRedemption(address indexed redeemer, address indexed collateralToken, bytes32 indexed parentCollectionId, bytes32 conditionId, uint256[] indexSets, uint256 payout) -func (_ConditionTokens *ConditionTokensFilterer) ParsePayoutRedemption(log types.Log) (*ConditionTokensPayoutRedemption, error) { - event := new(ConditionTokensPayoutRedemption) - if err := _ConditionTokens.contract.UnpackLog(event, "PayoutRedemption", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ConditionTokensPositionSplitIterator is returned from FilterPositionSplit and is used to iterate over the raw logs and unpacked data for PositionSplit events raised by the ConditionTokens contract. -type ConditionTokensPositionSplitIterator struct { - Event *ConditionTokensPositionSplit // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ConditionTokensPositionSplitIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ConditionTokensPositionSplit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ConditionTokensPositionSplit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ConditionTokensPositionSplitIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ConditionTokensPositionSplitIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ConditionTokensPositionSplit represents a PositionSplit event raised by the ConditionTokens contract. -type ConditionTokensPositionSplit struct { - Stakeholder common.Address - CollateralToken common.Address - ParentCollectionId [32]byte - ConditionId [32]byte - Partition []*big.Int - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterPositionSplit is a free log retrieval operation binding the contract event 0x2e6bb91f8cbcda0c93623c54d0403a43514fabc40084ec96b6d5379a74786298. -// -// Solidity: event PositionSplit(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) -func (_ConditionTokens *ConditionTokensFilterer) FilterPositionSplit(opts *bind.FilterOpts, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (*ConditionTokensPositionSplitIterator, error) { - - var stakeholderRule []interface{} - for _, stakeholderItem := range stakeholder { - stakeholderRule = append(stakeholderRule, stakeholderItem) - } - - var parentCollectionIdRule []interface{} - for _, parentCollectionIdItem := range parentCollectionId { - parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) - } - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "PositionSplit", stakeholderRule, parentCollectionIdRule, conditionIdRule) - if err != nil { - return nil, err - } - return &ConditionTokensPositionSplitIterator{contract: _ConditionTokens.contract, event: "PositionSplit", logs: logs, sub: sub}, nil -} - -// WatchPositionSplit is a free log subscription operation binding the contract event 0x2e6bb91f8cbcda0c93623c54d0403a43514fabc40084ec96b6d5379a74786298. -// -// Solidity: event PositionSplit(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) -func (_ConditionTokens *ConditionTokensFilterer) WatchPositionSplit(opts *bind.WatchOpts, sink chan<- *ConditionTokensPositionSplit, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (event.Subscription, error) { - - var stakeholderRule []interface{} - for _, stakeholderItem := range stakeholder { - stakeholderRule = append(stakeholderRule, stakeholderItem) - } - - var parentCollectionIdRule []interface{} - for _, parentCollectionIdItem := range parentCollectionId { - parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) - } - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "PositionSplit", stakeholderRule, parentCollectionIdRule, conditionIdRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ConditionTokensPositionSplit) - if err := _ConditionTokens.contract.UnpackLog(event, "PositionSplit", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParsePositionSplit is a log parse operation binding the contract event 0x2e6bb91f8cbcda0c93623c54d0403a43514fabc40084ec96b6d5379a74786298. -// -// Solidity: event PositionSplit(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) -func (_ConditionTokens *ConditionTokensFilterer) ParsePositionSplit(log types.Log) (*ConditionTokensPositionSplit, error) { - event := new(ConditionTokensPositionSplit) - if err := _ConditionTokens.contract.UnpackLog(event, "PositionSplit", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ConditionTokensPositionsMergeIterator is returned from FilterPositionsMerge and is used to iterate over the raw logs and unpacked data for PositionsMerge events raised by the ConditionTokens contract. -type ConditionTokensPositionsMergeIterator struct { - Event *ConditionTokensPositionsMerge // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ConditionTokensPositionsMergeIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ConditionTokensPositionsMerge) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ConditionTokensPositionsMerge) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ConditionTokensPositionsMergeIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ConditionTokensPositionsMergeIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ConditionTokensPositionsMerge represents a PositionsMerge event raised by the ConditionTokens contract. -type ConditionTokensPositionsMerge struct { - Stakeholder common.Address - CollateralToken common.Address - ParentCollectionId [32]byte - ConditionId [32]byte - Partition []*big.Int - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterPositionsMerge is a free log retrieval operation binding the contract event 0x6f13ca62553fcc2bcd2372180a43949c1e4cebba603901ede2f4e14f36b282ca. -// -// Solidity: event PositionsMerge(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) -func (_ConditionTokens *ConditionTokensFilterer) FilterPositionsMerge(opts *bind.FilterOpts, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (*ConditionTokensPositionsMergeIterator, error) { - - var stakeholderRule []interface{} - for _, stakeholderItem := range stakeholder { - stakeholderRule = append(stakeholderRule, stakeholderItem) - } - - var parentCollectionIdRule []interface{} - for _, parentCollectionIdItem := range parentCollectionId { - parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) - } - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "PositionsMerge", stakeholderRule, parentCollectionIdRule, conditionIdRule) - if err != nil { - return nil, err - } - return &ConditionTokensPositionsMergeIterator{contract: _ConditionTokens.contract, event: "PositionsMerge", logs: logs, sub: sub}, nil -} - -// WatchPositionsMerge is a free log subscription operation binding the contract event 0x6f13ca62553fcc2bcd2372180a43949c1e4cebba603901ede2f4e14f36b282ca. -// -// Solidity: event PositionsMerge(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) -func (_ConditionTokens *ConditionTokensFilterer) WatchPositionsMerge(opts *bind.WatchOpts, sink chan<- *ConditionTokensPositionsMerge, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (event.Subscription, error) { - - var stakeholderRule []interface{} - for _, stakeholderItem := range stakeholder { - stakeholderRule = append(stakeholderRule, stakeholderItem) - } - - var parentCollectionIdRule []interface{} - for _, parentCollectionIdItem := range parentCollectionId { - parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) - } - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - - logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "PositionsMerge", stakeholderRule, parentCollectionIdRule, conditionIdRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ConditionTokensPositionsMerge) - if err := _ConditionTokens.contract.UnpackLog(event, "PositionsMerge", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParsePositionsMerge is a log parse operation binding the contract event 0x6f13ca62553fcc2bcd2372180a43949c1e4cebba603901ede2f4e14f36b282ca. -// -// Solidity: event PositionsMerge(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) -func (_ConditionTokens *ConditionTokensFilterer) ParsePositionsMerge(log types.Log) (*ConditionTokensPositionsMerge, error) { - event := new(ConditionTokensPositionsMerge) - if err := _ConditionTokens.contract.UnpackLog(event, "PositionsMerge", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ConditionTokensTransferBatchIterator is returned from FilterTransferBatch and is used to iterate over the raw logs and unpacked data for TransferBatch events raised by the ConditionTokens contract. -type ConditionTokensTransferBatchIterator struct { - Event *ConditionTokensTransferBatch // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ConditionTokensTransferBatchIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ConditionTokensTransferBatch) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ConditionTokensTransferBatch) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ConditionTokensTransferBatchIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ConditionTokensTransferBatchIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ConditionTokensTransferBatch represents a TransferBatch event raised by the ConditionTokens contract. -type ConditionTokensTransferBatch struct { - Operator common.Address - From common.Address - To common.Address - Ids []*big.Int - Values []*big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTransferBatch is a free log retrieval operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb. -// -// Solidity: event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values) -func (_ConditionTokens *ConditionTokensFilterer) FilterTransferBatch(opts *bind.FilterOpts, operator []common.Address, from []common.Address, to []common.Address) (*ConditionTokensTransferBatchIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "TransferBatch", operatorRule, fromRule, toRule) - if err != nil { - return nil, err - } - return &ConditionTokensTransferBatchIterator{contract: _ConditionTokens.contract, event: "TransferBatch", logs: logs, sub: sub}, nil -} - -// WatchTransferBatch is a free log subscription operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb. -// -// Solidity: event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values) -func (_ConditionTokens *ConditionTokensFilterer) WatchTransferBatch(opts *bind.WatchOpts, sink chan<- *ConditionTokensTransferBatch, operator []common.Address, from []common.Address, to []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "TransferBatch", operatorRule, fromRule, toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ConditionTokensTransferBatch) - if err := _ConditionTokens.contract.UnpackLog(event, "TransferBatch", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseTransferBatch is a log parse operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb. -// -// Solidity: event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values) -func (_ConditionTokens *ConditionTokensFilterer) ParseTransferBatch(log types.Log) (*ConditionTokensTransferBatch, error) { - event := new(ConditionTokensTransferBatch) - if err := _ConditionTokens.contract.UnpackLog(event, "TransferBatch", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ConditionTokensTransferSingleIterator is returned from FilterTransferSingle and is used to iterate over the raw logs and unpacked data for TransferSingle events raised by the ConditionTokens contract. -type ConditionTokensTransferSingleIterator struct { - Event *ConditionTokensTransferSingle // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ConditionTokensTransferSingleIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ConditionTokensTransferSingle) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ConditionTokensTransferSingle) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ConditionTokensTransferSingleIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ConditionTokensTransferSingleIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ConditionTokensTransferSingle represents a TransferSingle event raised by the ConditionTokens contract. -type ConditionTokensTransferSingle struct { - Operator common.Address - From common.Address - To common.Address - Id *big.Int - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTransferSingle is a free log retrieval operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62. -// -// Solidity: event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value) -func (_ConditionTokens *ConditionTokensFilterer) FilterTransferSingle(opts *bind.FilterOpts, operator []common.Address, from []common.Address, to []common.Address) (*ConditionTokensTransferSingleIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "TransferSingle", operatorRule, fromRule, toRule) - if err != nil { - return nil, err - } - return &ConditionTokensTransferSingleIterator{contract: _ConditionTokens.contract, event: "TransferSingle", logs: logs, sub: sub}, nil -} - -// WatchTransferSingle is a free log subscription operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62. -// -// Solidity: event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value) -func (_ConditionTokens *ConditionTokensFilterer) WatchTransferSingle(opts *bind.WatchOpts, sink chan<- *ConditionTokensTransferSingle, operator []common.Address, from []common.Address, to []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "TransferSingle", operatorRule, fromRule, toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ConditionTokensTransferSingle) - if err := _ConditionTokens.contract.UnpackLog(event, "TransferSingle", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseTransferSingle is a log parse operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62. -// -// Solidity: event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value) -func (_ConditionTokens *ConditionTokensFilterer) ParseTransferSingle(log types.Log) (*ConditionTokensTransferSingle, error) { - event := new(ConditionTokensTransferSingle) - if err := _ConditionTokens.contract.UnpackLog(event, "TransferSingle", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ConditionTokensURIIterator is returned from FilterURI and is used to iterate over the raw logs and unpacked data for URI events raised by the ConditionTokens contract. -type ConditionTokensURIIterator struct { - Event *ConditionTokensURI // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ConditionTokensURIIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ConditionTokensURI) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ConditionTokensURI) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ConditionTokensURIIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ConditionTokensURIIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ConditionTokensURI represents a URI event raised by the ConditionTokens contract. -type ConditionTokensURI struct { - Value string - Id *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterURI is a free log retrieval operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b. -// -// Solidity: event URI(string value, uint256 indexed id) -func (_ConditionTokens *ConditionTokensFilterer) FilterURI(opts *bind.FilterOpts, id []*big.Int) (*ConditionTokensURIIterator, error) { - - var idRule []interface{} - for _, idItem := range id { - idRule = append(idRule, idItem) - } - - logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "URI", idRule) - if err != nil { - return nil, err - } - return &ConditionTokensURIIterator{contract: _ConditionTokens.contract, event: "URI", logs: logs, sub: sub}, nil -} - -// WatchURI is a free log subscription operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b. -// -// Solidity: event URI(string value, uint256 indexed id) -func (_ConditionTokens *ConditionTokensFilterer) WatchURI(opts *bind.WatchOpts, sink chan<- *ConditionTokensURI, id []*big.Int) (event.Subscription, error) { - - var idRule []interface{} - for _, idItem := range id { - idRule = append(idRule, idItem) - } - - logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "URI", idRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ConditionTokensURI) - if err := _ConditionTokens.contract.UnpackLog(event, "URI", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseURI is a log parse operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b. -// -// Solidity: event URI(string value, uint256 indexed id) -func (_ConditionTokens *ConditionTokensFilterer) ParseURI(log types.Log) (*ConditionTokensURI, error) { - event := new(ConditionTokensURI) - if err := _ConditionTokens.contract.UnpackLog(event, "URI", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/provider/ethereum/contract/polymarket/contract_ctf_exchange.go b/provider/ethereum/contract/polymarket/contract_ctf_exchange.go deleted file mode 100644 index 5e50527c..00000000 --- a/provider/ethereum/contract/polymarket/contract_ctf_exchange.go +++ /dev/null @@ -1,3566 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package polymarket - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// Order is an auto generated low-level Go binding around an user-defined struct. -type Order struct { - Salt *big.Int - Maker common.Address - Signer common.Address - Taker common.Address - TokenId *big.Int - MakerAmount *big.Int - TakerAmount *big.Int - Expiration *big.Int - Nonce *big.Int - FeeRateBps *big.Int - Side uint8 - SignatureType uint8 - Signature []byte -} - -// OrderStatus is an auto generated low-level Go binding around an user-defined struct. -type OrderStatus struct { - IsFilledOrCancelled bool - Remaining *big.Int -} - -// CTFExchangeMetaData contains all meta data concerning the CTFExchange contract. -var CTFExchangeMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_ctf\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_proxyFactory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_safeFactory\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FeeTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidComplement\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenId\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MakingGtRemaining\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MismatchedTokenIds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCrossing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOperator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderFilledOrCancelled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLittleTokensReceived\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"FeeCharged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newAdminAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOperatorAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderCancelled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"OrderFilled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"takerOrderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"takerOrderMaker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"}],\"name\":\"OrdersMatched\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldProxyFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProxyFactory\",\"type\":\"address\"}],\"name\":\"ProxyFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedAdmin\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedOperator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldSafeFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newSafeFactory\",\"type\":\"address\"}],\"name\":\"SafeFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token0\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"TokenRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingUnpaused\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"name\":\"addAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator_\",\"type\":\"address\"}],\"name\":\"addOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"admins\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"cancelOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"cancelOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"domainSeparator\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"fillAmount\",\"type\":\"uint256\"}],\"name\":\"fillOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"fillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"fillOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateral\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getComplement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCtf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getMaxFeeRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"getOrderStatus\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"internalType\":\"structOrderStatus\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPolyProxyFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getPolyProxyWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getProxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getSafeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isAdmin\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"isValidNonce\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"takerOrder\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"makerOrders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"takerFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"makerFillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"matchOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"operators\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"orderStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parentCollectionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"registerToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"removeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"removeOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOperatorRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"safeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProxyFactory\",\"type\":\"address\"}],\"name\":\"setProxyFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newSafeFactory\",\"type\":\"address\"}],\"name\":\"setSafeFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"}],\"name\":\"validateComplement\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrder\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrderSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"validateTokenId\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", -} - -// CTFExchangeABI is the input ABI used to generate the binding from. -// Deprecated: Use CTFExchangeMetaData.ABI instead. -var CTFExchangeABI = CTFExchangeMetaData.ABI - -// CTFExchange is an auto generated Go binding around an Ethereum contract. -type CTFExchange struct { - CTFExchangeCaller // Read-only binding to the contract - CTFExchangeTransactor // Write-only binding to the contract - CTFExchangeFilterer // Log filterer for contract events -} - -// CTFExchangeCaller is an auto generated read-only Go binding around an Ethereum contract. -type CTFExchangeCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// CTFExchangeTransactor is an auto generated write-only Go binding around an Ethereum contract. -type CTFExchangeTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// CTFExchangeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type CTFExchangeFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// CTFExchangeSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type CTFExchangeSession struct { - Contract *CTFExchange // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// CTFExchangeCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type CTFExchangeCallerSession struct { - Contract *CTFExchangeCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// CTFExchangeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type CTFExchangeTransactorSession struct { - Contract *CTFExchangeTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// CTFExchangeRaw is an auto generated low-level Go binding around an Ethereum contract. -type CTFExchangeRaw struct { - Contract *CTFExchange // Generic contract binding to access the raw methods on -} - -// CTFExchangeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type CTFExchangeCallerRaw struct { - Contract *CTFExchangeCaller // Generic read-only contract binding to access the raw methods on -} - -// CTFExchangeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type CTFExchangeTransactorRaw struct { - Contract *CTFExchangeTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewCTFExchange creates a new instance of CTFExchange, bound to a specific deployed contract. -func NewCTFExchange(address common.Address, backend bind.ContractBackend) (*CTFExchange, error) { - contract, err := bindCTFExchange(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &CTFExchange{CTFExchangeCaller: CTFExchangeCaller{contract: contract}, CTFExchangeTransactor: CTFExchangeTransactor{contract: contract}, CTFExchangeFilterer: CTFExchangeFilterer{contract: contract}}, nil -} - -// NewCTFExchangeCaller creates a new read-only instance of CTFExchange, bound to a specific deployed contract. -func NewCTFExchangeCaller(address common.Address, caller bind.ContractCaller) (*CTFExchangeCaller, error) { - contract, err := bindCTFExchange(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &CTFExchangeCaller{contract: contract}, nil -} - -// NewCTFExchangeTransactor creates a new write-only instance of CTFExchange, bound to a specific deployed contract. -func NewCTFExchangeTransactor(address common.Address, transactor bind.ContractTransactor) (*CTFExchangeTransactor, error) { - contract, err := bindCTFExchange(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &CTFExchangeTransactor{contract: contract}, nil -} - -// NewCTFExchangeFilterer creates a new log filterer instance of CTFExchange, bound to a specific deployed contract. -func NewCTFExchangeFilterer(address common.Address, filterer bind.ContractFilterer) (*CTFExchangeFilterer, error) { - contract, err := bindCTFExchange(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &CTFExchangeFilterer{contract: contract}, nil -} - -// bindCTFExchange binds a generic wrapper to an already deployed contract. -func bindCTFExchange(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := CTFExchangeMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_CTFExchange *CTFExchangeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _CTFExchange.Contract.CTFExchangeCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_CTFExchange *CTFExchangeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CTFExchange.Contract.CTFExchangeTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_CTFExchange *CTFExchangeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _CTFExchange.Contract.CTFExchangeTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_CTFExchange *CTFExchangeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _CTFExchange.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_CTFExchange *CTFExchangeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CTFExchange.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_CTFExchange *CTFExchangeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _CTFExchange.Contract.contract.Transact(opts, method, params...) -} - -// Admins is a free data retrieval call binding the contract method 0x429b62e5. -// -// Solidity: function admins(address ) view returns(uint256) -func (_CTFExchange *CTFExchangeCaller) Admins(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "admins", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Admins is a free data retrieval call binding the contract method 0x429b62e5. -// -// Solidity: function admins(address ) view returns(uint256) -func (_CTFExchange *CTFExchangeSession) Admins(arg0 common.Address) (*big.Int, error) { - return _CTFExchange.Contract.Admins(&_CTFExchange.CallOpts, arg0) -} - -// Admins is a free data retrieval call binding the contract method 0x429b62e5. -// -// Solidity: function admins(address ) view returns(uint256) -func (_CTFExchange *CTFExchangeCallerSession) Admins(arg0 common.Address) (*big.Int, error) { - return _CTFExchange.Contract.Admins(&_CTFExchange.CallOpts, arg0) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_CTFExchange *CTFExchangeCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "domainSeparator") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_CTFExchange *CTFExchangeSession) DomainSeparator() ([32]byte, error) { - return _CTFExchange.Contract.DomainSeparator(&_CTFExchange.CallOpts) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_CTFExchange *CTFExchangeCallerSession) DomainSeparator() ([32]byte, error) { - return _CTFExchange.Contract.DomainSeparator(&_CTFExchange.CallOpts) -} - -// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. -// -// Solidity: function getCollateral() view returns(address) -func (_CTFExchange *CTFExchangeCaller) GetCollateral(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getCollateral") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. -// -// Solidity: function getCollateral() view returns(address) -func (_CTFExchange *CTFExchangeSession) GetCollateral() (common.Address, error) { - return _CTFExchange.Contract.GetCollateral(&_CTFExchange.CallOpts) -} - -// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. -// -// Solidity: function getCollateral() view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) GetCollateral() (common.Address, error) { - return _CTFExchange.Contract.GetCollateral(&_CTFExchange.CallOpts) -} - -// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. -// -// Solidity: function getComplement(uint256 token) view returns(uint256) -func (_CTFExchange *CTFExchangeCaller) GetComplement(opts *bind.CallOpts, token *big.Int) (*big.Int, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getComplement", token) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. -// -// Solidity: function getComplement(uint256 token) view returns(uint256) -func (_CTFExchange *CTFExchangeSession) GetComplement(token *big.Int) (*big.Int, error) { - return _CTFExchange.Contract.GetComplement(&_CTFExchange.CallOpts, token) -} - -// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. -// -// Solidity: function getComplement(uint256 token) view returns(uint256) -func (_CTFExchange *CTFExchangeCallerSession) GetComplement(token *big.Int) (*big.Int, error) { - return _CTFExchange.Contract.GetComplement(&_CTFExchange.CallOpts, token) -} - -// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. -// -// Solidity: function getConditionId(uint256 token) view returns(bytes32) -func (_CTFExchange *CTFExchangeCaller) GetConditionId(opts *bind.CallOpts, token *big.Int) ([32]byte, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getConditionId", token) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. -// -// Solidity: function getConditionId(uint256 token) view returns(bytes32) -func (_CTFExchange *CTFExchangeSession) GetConditionId(token *big.Int) ([32]byte, error) { - return _CTFExchange.Contract.GetConditionId(&_CTFExchange.CallOpts, token) -} - -// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. -// -// Solidity: function getConditionId(uint256 token) view returns(bytes32) -func (_CTFExchange *CTFExchangeCallerSession) GetConditionId(token *big.Int) ([32]byte, error) { - return _CTFExchange.Contract.GetConditionId(&_CTFExchange.CallOpts, token) -} - -// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. -// -// Solidity: function getCtf() view returns(address) -func (_CTFExchange *CTFExchangeCaller) GetCtf(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getCtf") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. -// -// Solidity: function getCtf() view returns(address) -func (_CTFExchange *CTFExchangeSession) GetCtf() (common.Address, error) { - return _CTFExchange.Contract.GetCtf(&_CTFExchange.CallOpts) -} - -// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. -// -// Solidity: function getCtf() view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) GetCtf() (common.Address, error) { - return _CTFExchange.Contract.GetCtf(&_CTFExchange.CallOpts) -} - -// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. -// -// Solidity: function getMaxFeeRate() pure returns(uint256) -func (_CTFExchange *CTFExchangeCaller) GetMaxFeeRate(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getMaxFeeRate") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. -// -// Solidity: function getMaxFeeRate() pure returns(uint256) -func (_CTFExchange *CTFExchangeSession) GetMaxFeeRate() (*big.Int, error) { - return _CTFExchange.Contract.GetMaxFeeRate(&_CTFExchange.CallOpts) -} - -// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. -// -// Solidity: function getMaxFeeRate() pure returns(uint256) -func (_CTFExchange *CTFExchangeCallerSession) GetMaxFeeRate() (*big.Int, error) { - return _CTFExchange.Contract.GetMaxFeeRate(&_CTFExchange.CallOpts) -} - -// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. -// -// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) -func (_CTFExchange *CTFExchangeCaller) GetOrderStatus(opts *bind.CallOpts, orderHash [32]byte) (OrderStatus, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getOrderStatus", orderHash) - - if err != nil { - return *new(OrderStatus), err - } - - out0 := *abi.ConvertType(out[0], new(OrderStatus)).(*OrderStatus) - - return out0, err - -} - -// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. -// -// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) -func (_CTFExchange *CTFExchangeSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { - return _CTFExchange.Contract.GetOrderStatus(&_CTFExchange.CallOpts, orderHash) -} - -// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. -// -// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) -func (_CTFExchange *CTFExchangeCallerSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { - return _CTFExchange.Contract.GetOrderStatus(&_CTFExchange.CallOpts, orderHash) -} - -// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. -// -// Solidity: function getPolyProxyFactoryImplementation() view returns(address) -func (_CTFExchange *CTFExchangeCaller) GetPolyProxyFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getPolyProxyFactoryImplementation") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. -// -// Solidity: function getPolyProxyFactoryImplementation() view returns(address) -func (_CTFExchange *CTFExchangeSession) GetPolyProxyFactoryImplementation() (common.Address, error) { - return _CTFExchange.Contract.GetPolyProxyFactoryImplementation(&_CTFExchange.CallOpts) -} - -// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. -// -// Solidity: function getPolyProxyFactoryImplementation() view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) GetPolyProxyFactoryImplementation() (common.Address, error) { - return _CTFExchange.Contract.GetPolyProxyFactoryImplementation(&_CTFExchange.CallOpts) -} - -// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. -// -// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) -func (_CTFExchange *CTFExchangeCaller) GetPolyProxyWalletAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getPolyProxyWalletAddress", _addr) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. -// -// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) -func (_CTFExchange *CTFExchangeSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { - return _CTFExchange.Contract.GetPolyProxyWalletAddress(&_CTFExchange.CallOpts, _addr) -} - -// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. -// -// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { - return _CTFExchange.Contract.GetPolyProxyWalletAddress(&_CTFExchange.CallOpts, _addr) -} - -// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. -// -// Solidity: function getProxyFactory() view returns(address) -func (_CTFExchange *CTFExchangeCaller) GetProxyFactory(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getProxyFactory") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. -// -// Solidity: function getProxyFactory() view returns(address) -func (_CTFExchange *CTFExchangeSession) GetProxyFactory() (common.Address, error) { - return _CTFExchange.Contract.GetProxyFactory(&_CTFExchange.CallOpts) -} - -// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. -// -// Solidity: function getProxyFactory() view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) GetProxyFactory() (common.Address, error) { - return _CTFExchange.Contract.GetProxyFactory(&_CTFExchange.CallOpts) -} - -// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. -// -// Solidity: function getSafeAddress(address _addr) view returns(address) -func (_CTFExchange *CTFExchangeCaller) GetSafeAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getSafeAddress", _addr) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. -// -// Solidity: function getSafeAddress(address _addr) view returns(address) -func (_CTFExchange *CTFExchangeSession) GetSafeAddress(_addr common.Address) (common.Address, error) { - return _CTFExchange.Contract.GetSafeAddress(&_CTFExchange.CallOpts, _addr) -} - -// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. -// -// Solidity: function getSafeAddress(address _addr) view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) GetSafeAddress(_addr common.Address) (common.Address, error) { - return _CTFExchange.Contract.GetSafeAddress(&_CTFExchange.CallOpts, _addr) -} - -// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. -// -// Solidity: function getSafeFactory() view returns(address) -func (_CTFExchange *CTFExchangeCaller) GetSafeFactory(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getSafeFactory") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. -// -// Solidity: function getSafeFactory() view returns(address) -func (_CTFExchange *CTFExchangeSession) GetSafeFactory() (common.Address, error) { - return _CTFExchange.Contract.GetSafeFactory(&_CTFExchange.CallOpts) -} - -// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. -// -// Solidity: function getSafeFactory() view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) GetSafeFactory() (common.Address, error) { - return _CTFExchange.Contract.GetSafeFactory(&_CTFExchange.CallOpts) -} - -// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. -// -// Solidity: function getSafeFactoryImplementation() view returns(address) -func (_CTFExchange *CTFExchangeCaller) GetSafeFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "getSafeFactoryImplementation") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. -// -// Solidity: function getSafeFactoryImplementation() view returns(address) -func (_CTFExchange *CTFExchangeSession) GetSafeFactoryImplementation() (common.Address, error) { - return _CTFExchange.Contract.GetSafeFactoryImplementation(&_CTFExchange.CallOpts) -} - -// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. -// -// Solidity: function getSafeFactoryImplementation() view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) GetSafeFactoryImplementation() (common.Address, error) { - return _CTFExchange.Contract.GetSafeFactoryImplementation(&_CTFExchange.CallOpts) -} - -// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. -// -// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) -func (_CTFExchange *CTFExchangeCaller) HashOrder(opts *bind.CallOpts, order Order) ([32]byte, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "hashOrder", order) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. -// -// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) -func (_CTFExchange *CTFExchangeSession) HashOrder(order Order) ([32]byte, error) { - return _CTFExchange.Contract.HashOrder(&_CTFExchange.CallOpts, order) -} - -// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. -// -// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) -func (_CTFExchange *CTFExchangeCallerSession) HashOrder(order Order) ([32]byte, error) { - return _CTFExchange.Contract.HashOrder(&_CTFExchange.CallOpts, order) -} - -// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. -// -// Solidity: function isAdmin(address usr) view returns(bool) -func (_CTFExchange *CTFExchangeCaller) IsAdmin(opts *bind.CallOpts, usr common.Address) (bool, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "isAdmin", usr) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. -// -// Solidity: function isAdmin(address usr) view returns(bool) -func (_CTFExchange *CTFExchangeSession) IsAdmin(usr common.Address) (bool, error) { - return _CTFExchange.Contract.IsAdmin(&_CTFExchange.CallOpts, usr) -} - -// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. -// -// Solidity: function isAdmin(address usr) view returns(bool) -func (_CTFExchange *CTFExchangeCallerSession) IsAdmin(usr common.Address) (bool, error) { - return _CTFExchange.Contract.IsAdmin(&_CTFExchange.CallOpts, usr) -} - -// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. -// -// Solidity: function isOperator(address usr) view returns(bool) -func (_CTFExchange *CTFExchangeCaller) IsOperator(opts *bind.CallOpts, usr common.Address) (bool, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "isOperator", usr) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. -// -// Solidity: function isOperator(address usr) view returns(bool) -func (_CTFExchange *CTFExchangeSession) IsOperator(usr common.Address) (bool, error) { - return _CTFExchange.Contract.IsOperator(&_CTFExchange.CallOpts, usr) -} - -// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. -// -// Solidity: function isOperator(address usr) view returns(bool) -func (_CTFExchange *CTFExchangeCallerSession) IsOperator(usr common.Address) (bool, error) { - return _CTFExchange.Contract.IsOperator(&_CTFExchange.CallOpts, usr) -} - -// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. -// -// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) -func (_CTFExchange *CTFExchangeCaller) IsValidNonce(opts *bind.CallOpts, usr common.Address, nonce *big.Int) (bool, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "isValidNonce", usr, nonce) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. -// -// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) -func (_CTFExchange *CTFExchangeSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { - return _CTFExchange.Contract.IsValidNonce(&_CTFExchange.CallOpts, usr, nonce) -} - -// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. -// -// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) -func (_CTFExchange *CTFExchangeCallerSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { - return _CTFExchange.Contract.IsValidNonce(&_CTFExchange.CallOpts, usr, nonce) -} - -// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. -// -// Solidity: function nonces(address ) view returns(uint256) -func (_CTFExchange *CTFExchangeCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "nonces", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. -// -// Solidity: function nonces(address ) view returns(uint256) -func (_CTFExchange *CTFExchangeSession) Nonces(arg0 common.Address) (*big.Int, error) { - return _CTFExchange.Contract.Nonces(&_CTFExchange.CallOpts, arg0) -} - -// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. -// -// Solidity: function nonces(address ) view returns(uint256) -func (_CTFExchange *CTFExchangeCallerSession) Nonces(arg0 common.Address) (*big.Int, error) { - return _CTFExchange.Contract.Nonces(&_CTFExchange.CallOpts, arg0) -} - -// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. -// -// Solidity: function operators(address ) view returns(uint256) -func (_CTFExchange *CTFExchangeCaller) Operators(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "operators", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. -// -// Solidity: function operators(address ) view returns(uint256) -func (_CTFExchange *CTFExchangeSession) Operators(arg0 common.Address) (*big.Int, error) { - return _CTFExchange.Contract.Operators(&_CTFExchange.CallOpts, arg0) -} - -// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. -// -// Solidity: function operators(address ) view returns(uint256) -func (_CTFExchange *CTFExchangeCallerSession) Operators(arg0 common.Address) (*big.Int, error) { - return _CTFExchange.Contract.Operators(&_CTFExchange.CallOpts, arg0) -} - -// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. -// -// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) -func (_CTFExchange *CTFExchangeCaller) OrderStatus(opts *bind.CallOpts, arg0 [32]byte) (struct { - IsFilledOrCancelled bool - Remaining *big.Int -}, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "orderStatus", arg0) - - outstruct := new(struct { - IsFilledOrCancelled bool - Remaining *big.Int - }) - if err != nil { - return *outstruct, err - } - - outstruct.IsFilledOrCancelled = *abi.ConvertType(out[0], new(bool)).(*bool) - outstruct.Remaining = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. -// -// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) -func (_CTFExchange *CTFExchangeSession) OrderStatus(arg0 [32]byte) (struct { - IsFilledOrCancelled bool - Remaining *big.Int -}, error) { - return _CTFExchange.Contract.OrderStatus(&_CTFExchange.CallOpts, arg0) -} - -// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. -// -// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) -func (_CTFExchange *CTFExchangeCallerSession) OrderStatus(arg0 [32]byte) (struct { - IsFilledOrCancelled bool - Remaining *big.Int -}, error) { - return _CTFExchange.Contract.OrderStatus(&_CTFExchange.CallOpts, arg0) -} - -// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. -// -// Solidity: function parentCollectionId() view returns(bytes32) -func (_CTFExchange *CTFExchangeCaller) ParentCollectionId(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "parentCollectionId") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. -// -// Solidity: function parentCollectionId() view returns(bytes32) -func (_CTFExchange *CTFExchangeSession) ParentCollectionId() ([32]byte, error) { - return _CTFExchange.Contract.ParentCollectionId(&_CTFExchange.CallOpts) -} - -// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. -// -// Solidity: function parentCollectionId() view returns(bytes32) -func (_CTFExchange *CTFExchangeCallerSession) ParentCollectionId() ([32]byte, error) { - return _CTFExchange.Contract.ParentCollectionId(&_CTFExchange.CallOpts) -} - -// Paused is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(bool) -func (_CTFExchange *CTFExchangeCaller) Paused(opts *bind.CallOpts) (bool, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "paused") - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// Paused is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(bool) -func (_CTFExchange *CTFExchangeSession) Paused() (bool, error) { - return _CTFExchange.Contract.Paused(&_CTFExchange.CallOpts) -} - -// Paused is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(bool) -func (_CTFExchange *CTFExchangeCallerSession) Paused() (bool, error) { - return _CTFExchange.Contract.Paused(&_CTFExchange.CallOpts) -} - -// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. -// -// Solidity: function proxyFactory() view returns(address) -func (_CTFExchange *CTFExchangeCaller) ProxyFactory(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "proxyFactory") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. -// -// Solidity: function proxyFactory() view returns(address) -func (_CTFExchange *CTFExchangeSession) ProxyFactory() (common.Address, error) { - return _CTFExchange.Contract.ProxyFactory(&_CTFExchange.CallOpts) -} - -// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. -// -// Solidity: function proxyFactory() view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) ProxyFactory() (common.Address, error) { - return _CTFExchange.Contract.ProxyFactory(&_CTFExchange.CallOpts) -} - -// Registry is a free data retrieval call binding the contract method 0x5893253c. -// -// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) -func (_CTFExchange *CTFExchangeCaller) Registry(opts *bind.CallOpts, arg0 *big.Int) (struct { - Complement *big.Int - ConditionId [32]byte -}, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "registry", arg0) - - outstruct := new(struct { - Complement *big.Int - ConditionId [32]byte - }) - if err != nil { - return *outstruct, err - } - - outstruct.Complement = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.ConditionId = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) - - return *outstruct, err - -} - -// Registry is a free data retrieval call binding the contract method 0x5893253c. -// -// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) -func (_CTFExchange *CTFExchangeSession) Registry(arg0 *big.Int) (struct { - Complement *big.Int - ConditionId [32]byte -}, error) { - return _CTFExchange.Contract.Registry(&_CTFExchange.CallOpts, arg0) -} - -// Registry is a free data retrieval call binding the contract method 0x5893253c. -// -// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) -func (_CTFExchange *CTFExchangeCallerSession) Registry(arg0 *big.Int) (struct { - Complement *big.Int - ConditionId [32]byte -}, error) { - return _CTFExchange.Contract.Registry(&_CTFExchange.CallOpts, arg0) -} - -// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. -// -// Solidity: function safeFactory() view returns(address) -func (_CTFExchange *CTFExchangeCaller) SafeFactory(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "safeFactory") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. -// -// Solidity: function safeFactory() view returns(address) -func (_CTFExchange *CTFExchangeSession) SafeFactory() (common.Address, error) { - return _CTFExchange.Contract.SafeFactory(&_CTFExchange.CallOpts) -} - -// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. -// -// Solidity: function safeFactory() view returns(address) -func (_CTFExchange *CTFExchangeCallerSession) SafeFactory() (common.Address, error) { - return _CTFExchange.Contract.SafeFactory(&_CTFExchange.CallOpts) -} - -// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. -// -// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) -func (_CTFExchange *CTFExchangeCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "supportsInterface", interfaceId) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. -// -// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) -func (_CTFExchange *CTFExchangeSession) SupportsInterface(interfaceId [4]byte) (bool, error) { - return _CTFExchange.Contract.SupportsInterface(&_CTFExchange.CallOpts, interfaceId) -} - -// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. -// -// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) -func (_CTFExchange *CTFExchangeCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { - return _CTFExchange.Contract.SupportsInterface(&_CTFExchange.CallOpts, interfaceId) -} - -// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. -// -// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() -func (_CTFExchange *CTFExchangeCaller) ValidateComplement(opts *bind.CallOpts, token *big.Int, complement *big.Int) error { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "validateComplement", token, complement) - - if err != nil { - return err - } - - return err - -} - -// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. -// -// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() -func (_CTFExchange *CTFExchangeSession) ValidateComplement(token *big.Int, complement *big.Int) error { - return _CTFExchange.Contract.ValidateComplement(&_CTFExchange.CallOpts, token, complement) -} - -// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. -// -// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() -func (_CTFExchange *CTFExchangeCallerSession) ValidateComplement(token *big.Int, complement *big.Int) error { - return _CTFExchange.Contract.ValidateComplement(&_CTFExchange.CallOpts, token, complement) -} - -// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. -// -// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_CTFExchange *CTFExchangeCaller) ValidateOrder(opts *bind.CallOpts, order Order) error { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "validateOrder", order) - - if err != nil { - return err - } - - return err - -} - -// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. -// -// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_CTFExchange *CTFExchangeSession) ValidateOrder(order Order) error { - return _CTFExchange.Contract.ValidateOrder(&_CTFExchange.CallOpts, order) -} - -// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. -// -// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_CTFExchange *CTFExchangeCallerSession) ValidateOrder(order Order) error { - return _CTFExchange.Contract.ValidateOrder(&_CTFExchange.CallOpts, order) -} - -// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. -// -// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_CTFExchange *CTFExchangeCaller) ValidateOrderSignature(opts *bind.CallOpts, orderHash [32]byte, order Order) error { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "validateOrderSignature", orderHash, order) - - if err != nil { - return err - } - - return err - -} - -// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. -// -// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_CTFExchange *CTFExchangeSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { - return _CTFExchange.Contract.ValidateOrderSignature(&_CTFExchange.CallOpts, orderHash, order) -} - -// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. -// -// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_CTFExchange *CTFExchangeCallerSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { - return _CTFExchange.Contract.ValidateOrderSignature(&_CTFExchange.CallOpts, orderHash, order) -} - -// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. -// -// Solidity: function validateTokenId(uint256 tokenId) view returns() -func (_CTFExchange *CTFExchangeCaller) ValidateTokenId(opts *bind.CallOpts, tokenId *big.Int) error { - var out []interface{} - err := _CTFExchange.contract.Call(opts, &out, "validateTokenId", tokenId) - - if err != nil { - return err - } - - return err - -} - -// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. -// -// Solidity: function validateTokenId(uint256 tokenId) view returns() -func (_CTFExchange *CTFExchangeSession) ValidateTokenId(tokenId *big.Int) error { - return _CTFExchange.Contract.ValidateTokenId(&_CTFExchange.CallOpts, tokenId) -} - -// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. -// -// Solidity: function validateTokenId(uint256 tokenId) view returns() -func (_CTFExchange *CTFExchangeCallerSession) ValidateTokenId(tokenId *big.Int) error { - return _CTFExchange.Contract.ValidateTokenId(&_CTFExchange.CallOpts, tokenId) -} - -// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. -// -// Solidity: function addAdmin(address admin_) returns() -func (_CTFExchange *CTFExchangeTransactor) AddAdmin(opts *bind.TransactOpts, admin_ common.Address) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "addAdmin", admin_) -} - -// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. -// -// Solidity: function addAdmin(address admin_) returns() -func (_CTFExchange *CTFExchangeSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.AddAdmin(&_CTFExchange.TransactOpts, admin_) -} - -// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. -// -// Solidity: function addAdmin(address admin_) returns() -func (_CTFExchange *CTFExchangeTransactorSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.AddAdmin(&_CTFExchange.TransactOpts, admin_) -} - -// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. -// -// Solidity: function addOperator(address operator_) returns() -func (_CTFExchange *CTFExchangeTransactor) AddOperator(opts *bind.TransactOpts, operator_ common.Address) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "addOperator", operator_) -} - -// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. -// -// Solidity: function addOperator(address operator_) returns() -func (_CTFExchange *CTFExchangeSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.AddOperator(&_CTFExchange.TransactOpts, operator_) -} - -// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. -// -// Solidity: function addOperator(address operator_) returns() -func (_CTFExchange *CTFExchangeTransactorSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.AddOperator(&_CTFExchange.TransactOpts, operator_) -} - -// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. -// -// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() -func (_CTFExchange *CTFExchangeTransactor) CancelOrder(opts *bind.TransactOpts, order Order) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "cancelOrder", order) -} - -// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. -// -// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() -func (_CTFExchange *CTFExchangeSession) CancelOrder(order Order) (*types.Transaction, error) { - return _CTFExchange.Contract.CancelOrder(&_CTFExchange.TransactOpts, order) -} - -// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. -// -// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() -func (_CTFExchange *CTFExchangeTransactorSession) CancelOrder(order Order) (*types.Transaction, error) { - return _CTFExchange.Contract.CancelOrder(&_CTFExchange.TransactOpts, order) -} - -// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. -// -// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() -func (_CTFExchange *CTFExchangeTransactor) CancelOrders(opts *bind.TransactOpts, orders []Order) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "cancelOrders", orders) -} - -// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. -// -// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() -func (_CTFExchange *CTFExchangeSession) CancelOrders(orders []Order) (*types.Transaction, error) { - return _CTFExchange.Contract.CancelOrders(&_CTFExchange.TransactOpts, orders) -} - -// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. -// -// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() -func (_CTFExchange *CTFExchangeTransactorSession) CancelOrders(orders []Order) (*types.Transaction, error) { - return _CTFExchange.Contract.CancelOrders(&_CTFExchange.TransactOpts, orders) -} - -// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. -// -// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() -func (_CTFExchange *CTFExchangeTransactor) FillOrder(opts *bind.TransactOpts, order Order, fillAmount *big.Int) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "fillOrder", order, fillAmount) -} - -// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. -// -// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() -func (_CTFExchange *CTFExchangeSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { - return _CTFExchange.Contract.FillOrder(&_CTFExchange.TransactOpts, order, fillAmount) -} - -// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. -// -// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() -func (_CTFExchange *CTFExchangeTransactorSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { - return _CTFExchange.Contract.FillOrder(&_CTFExchange.TransactOpts, order, fillAmount) -} - -// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. -// -// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() -func (_CTFExchange *CTFExchangeTransactor) FillOrders(opts *bind.TransactOpts, orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "fillOrders", orders, fillAmounts) -} - -// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. -// -// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() -func (_CTFExchange *CTFExchangeSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { - return _CTFExchange.Contract.FillOrders(&_CTFExchange.TransactOpts, orders, fillAmounts) -} - -// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. -// -// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() -func (_CTFExchange *CTFExchangeTransactorSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { - return _CTFExchange.Contract.FillOrders(&_CTFExchange.TransactOpts, orders, fillAmounts) -} - -// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. -// -// Solidity: function incrementNonce() returns() -func (_CTFExchange *CTFExchangeTransactor) IncrementNonce(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "incrementNonce") -} - -// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. -// -// Solidity: function incrementNonce() returns() -func (_CTFExchange *CTFExchangeSession) IncrementNonce() (*types.Transaction, error) { - return _CTFExchange.Contract.IncrementNonce(&_CTFExchange.TransactOpts) -} - -// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. -// -// Solidity: function incrementNonce() returns() -func (_CTFExchange *CTFExchangeTransactorSession) IncrementNonce() (*types.Transaction, error) { - return _CTFExchange.Contract.IncrementNonce(&_CTFExchange.TransactOpts) -} - -// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. -// -// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() -func (_CTFExchange *CTFExchangeTransactor) MatchOrders(opts *bind.TransactOpts, takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "matchOrders", takerOrder, makerOrders, takerFillAmount, makerFillAmounts) -} - -// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. -// -// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() -func (_CTFExchange *CTFExchangeSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { - return _CTFExchange.Contract.MatchOrders(&_CTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) -} - -// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. -// -// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() -func (_CTFExchange *CTFExchangeTransactorSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { - return _CTFExchange.Contract.MatchOrders(&_CTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) -} - -// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. -// -// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) -func (_CTFExchange *CTFExchangeTransactor) OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "onERC1155BatchReceived", arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. -// -// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) -func (_CTFExchange *CTFExchangeSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { - return _CTFExchange.Contract.OnERC1155BatchReceived(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. -// -// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) -func (_CTFExchange *CTFExchangeTransactorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { - return _CTFExchange.Contract.OnERC1155BatchReceived(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. -// -// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) -func (_CTFExchange *CTFExchangeTransactor) OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "onERC1155Received", arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. -// -// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) -func (_CTFExchange *CTFExchangeSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { - return _CTFExchange.Contract.OnERC1155Received(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. -// -// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) -func (_CTFExchange *CTFExchangeTransactorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { - return _CTFExchange.Contract.OnERC1155Received(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) -} - -// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. -// -// Solidity: function pauseTrading() returns() -func (_CTFExchange *CTFExchangeTransactor) PauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "pauseTrading") -} - -// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. -// -// Solidity: function pauseTrading() returns() -func (_CTFExchange *CTFExchangeSession) PauseTrading() (*types.Transaction, error) { - return _CTFExchange.Contract.PauseTrading(&_CTFExchange.TransactOpts) -} - -// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. -// -// Solidity: function pauseTrading() returns() -func (_CTFExchange *CTFExchangeTransactorSession) PauseTrading() (*types.Transaction, error) { - return _CTFExchange.Contract.PauseTrading(&_CTFExchange.TransactOpts) -} - -// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. -// -// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() -func (_CTFExchange *CTFExchangeTransactor) RegisterToken(opts *bind.TransactOpts, token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "registerToken", token, complement, conditionId) -} - -// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. -// -// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() -func (_CTFExchange *CTFExchangeSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { - return _CTFExchange.Contract.RegisterToken(&_CTFExchange.TransactOpts, token, complement, conditionId) -} - -// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. -// -// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() -func (_CTFExchange *CTFExchangeTransactorSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { - return _CTFExchange.Contract.RegisterToken(&_CTFExchange.TransactOpts, token, complement, conditionId) -} - -// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. -// -// Solidity: function removeAdmin(address admin) returns() -func (_CTFExchange *CTFExchangeTransactor) RemoveAdmin(opts *bind.TransactOpts, admin common.Address) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "removeAdmin", admin) -} - -// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. -// -// Solidity: function removeAdmin(address admin) returns() -func (_CTFExchange *CTFExchangeSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.RemoveAdmin(&_CTFExchange.TransactOpts, admin) -} - -// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. -// -// Solidity: function removeAdmin(address admin) returns() -func (_CTFExchange *CTFExchangeTransactorSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.RemoveAdmin(&_CTFExchange.TransactOpts, admin) -} - -// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. -// -// Solidity: function removeOperator(address operator) returns() -func (_CTFExchange *CTFExchangeTransactor) RemoveOperator(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "removeOperator", operator) -} - -// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. -// -// Solidity: function removeOperator(address operator) returns() -func (_CTFExchange *CTFExchangeSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.RemoveOperator(&_CTFExchange.TransactOpts, operator) -} - -// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. -// -// Solidity: function removeOperator(address operator) returns() -func (_CTFExchange *CTFExchangeTransactorSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.RemoveOperator(&_CTFExchange.TransactOpts, operator) -} - -// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. -// -// Solidity: function renounceAdminRole() returns() -func (_CTFExchange *CTFExchangeTransactor) RenounceAdminRole(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "renounceAdminRole") -} - -// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. -// -// Solidity: function renounceAdminRole() returns() -func (_CTFExchange *CTFExchangeSession) RenounceAdminRole() (*types.Transaction, error) { - return _CTFExchange.Contract.RenounceAdminRole(&_CTFExchange.TransactOpts) -} - -// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. -// -// Solidity: function renounceAdminRole() returns() -func (_CTFExchange *CTFExchangeTransactorSession) RenounceAdminRole() (*types.Transaction, error) { - return _CTFExchange.Contract.RenounceAdminRole(&_CTFExchange.TransactOpts) -} - -// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. -// -// Solidity: function renounceOperatorRole() returns() -func (_CTFExchange *CTFExchangeTransactor) RenounceOperatorRole(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "renounceOperatorRole") -} - -// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. -// -// Solidity: function renounceOperatorRole() returns() -func (_CTFExchange *CTFExchangeSession) RenounceOperatorRole() (*types.Transaction, error) { - return _CTFExchange.Contract.RenounceOperatorRole(&_CTFExchange.TransactOpts) -} - -// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. -// -// Solidity: function renounceOperatorRole() returns() -func (_CTFExchange *CTFExchangeTransactorSession) RenounceOperatorRole() (*types.Transaction, error) { - return _CTFExchange.Contract.RenounceOperatorRole(&_CTFExchange.TransactOpts) -} - -// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. -// -// Solidity: function setProxyFactory(address _newProxyFactory) returns() -func (_CTFExchange *CTFExchangeTransactor) SetProxyFactory(opts *bind.TransactOpts, _newProxyFactory common.Address) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "setProxyFactory", _newProxyFactory) -} - -// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. -// -// Solidity: function setProxyFactory(address _newProxyFactory) returns() -func (_CTFExchange *CTFExchangeSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.SetProxyFactory(&_CTFExchange.TransactOpts, _newProxyFactory) -} - -// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. -// -// Solidity: function setProxyFactory(address _newProxyFactory) returns() -func (_CTFExchange *CTFExchangeTransactorSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.SetProxyFactory(&_CTFExchange.TransactOpts, _newProxyFactory) -} - -// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. -// -// Solidity: function setSafeFactory(address _newSafeFactory) returns() -func (_CTFExchange *CTFExchangeTransactor) SetSafeFactory(opts *bind.TransactOpts, _newSafeFactory common.Address) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "setSafeFactory", _newSafeFactory) -} - -// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. -// -// Solidity: function setSafeFactory(address _newSafeFactory) returns() -func (_CTFExchange *CTFExchangeSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.SetSafeFactory(&_CTFExchange.TransactOpts, _newSafeFactory) -} - -// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. -// -// Solidity: function setSafeFactory(address _newSafeFactory) returns() -func (_CTFExchange *CTFExchangeTransactorSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { - return _CTFExchange.Contract.SetSafeFactory(&_CTFExchange.TransactOpts, _newSafeFactory) -} - -// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. -// -// Solidity: function unpauseTrading() returns() -func (_CTFExchange *CTFExchangeTransactor) UnpauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CTFExchange.contract.Transact(opts, "unpauseTrading") -} - -// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. -// -// Solidity: function unpauseTrading() returns() -func (_CTFExchange *CTFExchangeSession) UnpauseTrading() (*types.Transaction, error) { - return _CTFExchange.Contract.UnpauseTrading(&_CTFExchange.TransactOpts) -} - -// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. -// -// Solidity: function unpauseTrading() returns() -func (_CTFExchange *CTFExchangeTransactorSession) UnpauseTrading() (*types.Transaction, error) { - return _CTFExchange.Contract.UnpauseTrading(&_CTFExchange.TransactOpts) -} - -// CTFExchangeFeeChargedIterator is returned from FilterFeeCharged and is used to iterate over the raw logs and unpacked data for FeeCharged events raised by the CTFExchange contract. -type CTFExchangeFeeChargedIterator struct { - Event *CTFExchangeFeeCharged // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeFeeChargedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeFeeCharged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeFeeCharged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeFeeChargedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeFeeChargedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeFeeCharged represents a FeeCharged event raised by the CTFExchange contract. -type CTFExchangeFeeCharged struct { - Receiver common.Address - TokenId *big.Int - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterFeeCharged is a free log retrieval operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. -// -// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) -func (_CTFExchange *CTFExchangeFilterer) FilterFeeCharged(opts *bind.FilterOpts, receiver []common.Address) (*CTFExchangeFeeChargedIterator, error) { - - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "FeeCharged", receiverRule) - if err != nil { - return nil, err - } - return &CTFExchangeFeeChargedIterator{contract: _CTFExchange.contract, event: "FeeCharged", logs: logs, sub: sub}, nil -} - -// WatchFeeCharged is a free log subscription operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. -// -// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) -func (_CTFExchange *CTFExchangeFilterer) WatchFeeCharged(opts *bind.WatchOpts, sink chan<- *CTFExchangeFeeCharged, receiver []common.Address) (event.Subscription, error) { - - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "FeeCharged", receiverRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeFeeCharged) - if err := _CTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseFeeCharged is a log parse operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. -// -// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) -func (_CTFExchange *CTFExchangeFilterer) ParseFeeCharged(log types.Log) (*CTFExchangeFeeCharged, error) { - event := new(CTFExchangeFeeCharged) - if err := _CTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeNewAdminIterator is returned from FilterNewAdmin and is used to iterate over the raw logs and unpacked data for NewAdmin events raised by the CTFExchange contract. -type CTFExchangeNewAdminIterator struct { - Event *CTFExchangeNewAdmin // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeNewAdminIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeNewAdmin) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeNewAdmin) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeNewAdminIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeNewAdminIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeNewAdmin represents a NewAdmin event raised by the CTFExchange contract. -type CTFExchangeNewAdmin struct { - NewAdminAddress common.Address - Admin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterNewAdmin is a free log retrieval operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. -// -// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) FilterNewAdmin(opts *bind.FilterOpts, newAdminAddress []common.Address, admin []common.Address) (*CTFExchangeNewAdminIterator, error) { - - var newAdminAddressRule []interface{} - for _, newAdminAddressItem := range newAdminAddress { - newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) - if err != nil { - return nil, err - } - return &CTFExchangeNewAdminIterator{contract: _CTFExchange.contract, event: "NewAdmin", logs: logs, sub: sub}, nil -} - -// WatchNewAdmin is a free log subscription operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. -// -// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) WatchNewAdmin(opts *bind.WatchOpts, sink chan<- *CTFExchangeNewAdmin, newAdminAddress []common.Address, admin []common.Address) (event.Subscription, error) { - - var newAdminAddressRule []interface{} - for _, newAdminAddressItem := range newAdminAddress { - newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeNewAdmin) - if err := _CTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseNewAdmin is a log parse operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. -// -// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) ParseNewAdmin(log types.Log) (*CTFExchangeNewAdmin, error) { - event := new(CTFExchangeNewAdmin) - if err := _CTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeNewOperatorIterator is returned from FilterNewOperator and is used to iterate over the raw logs and unpacked data for NewOperator events raised by the CTFExchange contract. -type CTFExchangeNewOperatorIterator struct { - Event *CTFExchangeNewOperator // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeNewOperatorIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeNewOperator) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeNewOperator) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeNewOperatorIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeNewOperatorIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeNewOperator represents a NewOperator event raised by the CTFExchange contract. -type CTFExchangeNewOperator struct { - NewOperatorAddress common.Address - Admin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterNewOperator is a free log retrieval operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. -// -// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) FilterNewOperator(opts *bind.FilterOpts, newOperatorAddress []common.Address, admin []common.Address) (*CTFExchangeNewOperatorIterator, error) { - - var newOperatorAddressRule []interface{} - for _, newOperatorAddressItem := range newOperatorAddress { - newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) - if err != nil { - return nil, err - } - return &CTFExchangeNewOperatorIterator{contract: _CTFExchange.contract, event: "NewOperator", logs: logs, sub: sub}, nil -} - -// WatchNewOperator is a free log subscription operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. -// -// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) WatchNewOperator(opts *bind.WatchOpts, sink chan<- *CTFExchangeNewOperator, newOperatorAddress []common.Address, admin []common.Address) (event.Subscription, error) { - - var newOperatorAddressRule []interface{} - for _, newOperatorAddressItem := range newOperatorAddress { - newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeNewOperator) - if err := _CTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseNewOperator is a log parse operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. -// -// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) ParseNewOperator(log types.Log) (*CTFExchangeNewOperator, error) { - event := new(CTFExchangeNewOperator) - if err := _CTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeOrderCancelledIterator is returned from FilterOrderCancelled and is used to iterate over the raw logs and unpacked data for OrderCancelled events raised by the CTFExchange contract. -type CTFExchangeOrderCancelledIterator struct { - Event *CTFExchangeOrderCancelled // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeOrderCancelledIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeOrderCancelled) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeOrderCancelled) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeOrderCancelledIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeOrderCancelledIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeOrderCancelled represents a OrderCancelled event raised by the CTFExchange contract. -type CTFExchangeOrderCancelled struct { - OrderHash [32]byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOrderCancelled is a free log retrieval operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. -// -// Solidity: event OrderCancelled(bytes32 indexed orderHash) -func (_CTFExchange *CTFExchangeFilterer) FilterOrderCancelled(opts *bind.FilterOpts, orderHash [][32]byte) (*CTFExchangeOrderCancelledIterator, error) { - - var orderHashRule []interface{} - for _, orderHashItem := range orderHash { - orderHashRule = append(orderHashRule, orderHashItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "OrderCancelled", orderHashRule) - if err != nil { - return nil, err - } - return &CTFExchangeOrderCancelledIterator{contract: _CTFExchange.contract, event: "OrderCancelled", logs: logs, sub: sub}, nil -} - -// WatchOrderCancelled is a free log subscription operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. -// -// Solidity: event OrderCancelled(bytes32 indexed orderHash) -func (_CTFExchange *CTFExchangeFilterer) WatchOrderCancelled(opts *bind.WatchOpts, sink chan<- *CTFExchangeOrderCancelled, orderHash [][32]byte) (event.Subscription, error) { - - var orderHashRule []interface{} - for _, orderHashItem := range orderHash { - orderHashRule = append(orderHashRule, orderHashItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "OrderCancelled", orderHashRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeOrderCancelled) - if err := _CTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOrderCancelled is a log parse operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. -// -// Solidity: event OrderCancelled(bytes32 indexed orderHash) -func (_CTFExchange *CTFExchangeFilterer) ParseOrderCancelled(log types.Log) (*CTFExchangeOrderCancelled, error) { - event := new(CTFExchangeOrderCancelled) - if err := _CTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeOrderFilledIterator is returned from FilterOrderFilled and is used to iterate over the raw logs and unpacked data for OrderFilled events raised by the CTFExchange contract. -type CTFExchangeOrderFilledIterator struct { - Event *CTFExchangeOrderFilled // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeOrderFilledIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeOrderFilled) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeOrderFilled) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeOrderFilledIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeOrderFilledIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeOrderFilled represents a OrderFilled event raised by the CTFExchange contract. -type CTFExchangeOrderFilled struct { - OrderHash [32]byte - Maker common.Address - Taker common.Address - MakerAssetId *big.Int - TakerAssetId *big.Int - MakerAmountFilled *big.Int - TakerAmountFilled *big.Int - Fee *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOrderFilled is a free log retrieval operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. -// -// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) -func (_CTFExchange *CTFExchangeFilterer) FilterOrderFilled(opts *bind.FilterOpts, orderHash [][32]byte, maker []common.Address, taker []common.Address) (*CTFExchangeOrderFilledIterator, error) { - - var orderHashRule []interface{} - for _, orderHashItem := range orderHash { - orderHashRule = append(orderHashRule, orderHashItem) - } - var makerRule []interface{} - for _, makerItem := range maker { - makerRule = append(makerRule, makerItem) - } - var takerRule []interface{} - for _, takerItem := range taker { - takerRule = append(takerRule, takerItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) - if err != nil { - return nil, err - } - return &CTFExchangeOrderFilledIterator{contract: _CTFExchange.contract, event: "OrderFilled", logs: logs, sub: sub}, nil -} - -// WatchOrderFilled is a free log subscription operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. -// -// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) -func (_CTFExchange *CTFExchangeFilterer) WatchOrderFilled(opts *bind.WatchOpts, sink chan<- *CTFExchangeOrderFilled, orderHash [][32]byte, maker []common.Address, taker []common.Address) (event.Subscription, error) { - - var orderHashRule []interface{} - for _, orderHashItem := range orderHash { - orderHashRule = append(orderHashRule, orderHashItem) - } - var makerRule []interface{} - for _, makerItem := range maker { - makerRule = append(makerRule, makerItem) - } - var takerRule []interface{} - for _, takerItem := range taker { - takerRule = append(takerRule, takerItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeOrderFilled) - if err := _CTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOrderFilled is a log parse operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. -// -// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) -func (_CTFExchange *CTFExchangeFilterer) ParseOrderFilled(log types.Log) (*CTFExchangeOrderFilled, error) { - event := new(CTFExchangeOrderFilled) - if err := _CTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeOrdersMatchedIterator is returned from FilterOrdersMatched and is used to iterate over the raw logs and unpacked data for OrdersMatched events raised by the CTFExchange contract. -type CTFExchangeOrdersMatchedIterator struct { - Event *CTFExchangeOrdersMatched // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeOrdersMatchedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeOrdersMatched) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeOrdersMatched) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeOrdersMatchedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeOrdersMatchedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeOrdersMatched represents a OrdersMatched event raised by the CTFExchange contract. -type CTFExchangeOrdersMatched struct { - TakerOrderHash [32]byte - TakerOrderMaker common.Address - MakerAssetId *big.Int - TakerAssetId *big.Int - MakerAmountFilled *big.Int - TakerAmountFilled *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOrdersMatched is a free log retrieval operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. -// -// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) -func (_CTFExchange *CTFExchangeFilterer) FilterOrdersMatched(opts *bind.FilterOpts, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (*CTFExchangeOrdersMatchedIterator, error) { - - var takerOrderHashRule []interface{} - for _, takerOrderHashItem := range takerOrderHash { - takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) - } - var takerOrderMakerRule []interface{} - for _, takerOrderMakerItem := range takerOrderMaker { - takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) - if err != nil { - return nil, err - } - return &CTFExchangeOrdersMatchedIterator{contract: _CTFExchange.contract, event: "OrdersMatched", logs: logs, sub: sub}, nil -} - -// WatchOrdersMatched is a free log subscription operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. -// -// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) -func (_CTFExchange *CTFExchangeFilterer) WatchOrdersMatched(opts *bind.WatchOpts, sink chan<- *CTFExchangeOrdersMatched, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (event.Subscription, error) { - - var takerOrderHashRule []interface{} - for _, takerOrderHashItem := range takerOrderHash { - takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) - } - var takerOrderMakerRule []interface{} - for _, takerOrderMakerItem := range takerOrderMaker { - takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeOrdersMatched) - if err := _CTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOrdersMatched is a log parse operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. -// -// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) -func (_CTFExchange *CTFExchangeFilterer) ParseOrdersMatched(log types.Log) (*CTFExchangeOrdersMatched, error) { - event := new(CTFExchangeOrdersMatched) - if err := _CTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeProxyFactoryUpdatedIterator is returned from FilterProxyFactoryUpdated and is used to iterate over the raw logs and unpacked data for ProxyFactoryUpdated events raised by the CTFExchange contract. -type CTFExchangeProxyFactoryUpdatedIterator struct { - Event *CTFExchangeProxyFactoryUpdated // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeProxyFactoryUpdatedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeProxyFactoryUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeProxyFactoryUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeProxyFactoryUpdatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeProxyFactoryUpdatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeProxyFactoryUpdated represents a ProxyFactoryUpdated event raised by the CTFExchange contract. -type CTFExchangeProxyFactoryUpdated struct { - OldProxyFactory common.Address - NewProxyFactory common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterProxyFactoryUpdated is a free log retrieval operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. -// -// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) -func (_CTFExchange *CTFExchangeFilterer) FilterProxyFactoryUpdated(opts *bind.FilterOpts, oldProxyFactory []common.Address, newProxyFactory []common.Address) (*CTFExchangeProxyFactoryUpdatedIterator, error) { - - var oldProxyFactoryRule []interface{} - for _, oldProxyFactoryItem := range oldProxyFactory { - oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) - } - var newProxyFactoryRule []interface{} - for _, newProxyFactoryItem := range newProxyFactory { - newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) - if err != nil { - return nil, err - } - return &CTFExchangeProxyFactoryUpdatedIterator{contract: _CTFExchange.contract, event: "ProxyFactoryUpdated", logs: logs, sub: sub}, nil -} - -// WatchProxyFactoryUpdated is a free log subscription operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. -// -// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) -func (_CTFExchange *CTFExchangeFilterer) WatchProxyFactoryUpdated(opts *bind.WatchOpts, sink chan<- *CTFExchangeProxyFactoryUpdated, oldProxyFactory []common.Address, newProxyFactory []common.Address) (event.Subscription, error) { - - var oldProxyFactoryRule []interface{} - for _, oldProxyFactoryItem := range oldProxyFactory { - oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) - } - var newProxyFactoryRule []interface{} - for _, newProxyFactoryItem := range newProxyFactory { - newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeProxyFactoryUpdated) - if err := _CTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseProxyFactoryUpdated is a log parse operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. -// -// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) -func (_CTFExchange *CTFExchangeFilterer) ParseProxyFactoryUpdated(log types.Log) (*CTFExchangeProxyFactoryUpdated, error) { - event := new(CTFExchangeProxyFactoryUpdated) - if err := _CTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeRemovedAdminIterator is returned from FilterRemovedAdmin and is used to iterate over the raw logs and unpacked data for RemovedAdmin events raised by the CTFExchange contract. -type CTFExchangeRemovedAdminIterator struct { - Event *CTFExchangeRemovedAdmin // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeRemovedAdminIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeRemovedAdmin) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeRemovedAdmin) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeRemovedAdminIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeRemovedAdminIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeRemovedAdmin represents a RemovedAdmin event raised by the CTFExchange contract. -type CTFExchangeRemovedAdmin struct { - RemovedAdmin common.Address - Admin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterRemovedAdmin is a free log retrieval operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. -// -// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) FilterRemovedAdmin(opts *bind.FilterOpts, removedAdmin []common.Address, admin []common.Address) (*CTFExchangeRemovedAdminIterator, error) { - - var removedAdminRule []interface{} - for _, removedAdminItem := range removedAdmin { - removedAdminRule = append(removedAdminRule, removedAdminItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) - if err != nil { - return nil, err - } - return &CTFExchangeRemovedAdminIterator{contract: _CTFExchange.contract, event: "RemovedAdmin", logs: logs, sub: sub}, nil -} - -// WatchRemovedAdmin is a free log subscription operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. -// -// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) WatchRemovedAdmin(opts *bind.WatchOpts, sink chan<- *CTFExchangeRemovedAdmin, removedAdmin []common.Address, admin []common.Address) (event.Subscription, error) { - - var removedAdminRule []interface{} - for _, removedAdminItem := range removedAdmin { - removedAdminRule = append(removedAdminRule, removedAdminItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeRemovedAdmin) - if err := _CTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseRemovedAdmin is a log parse operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. -// -// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) ParseRemovedAdmin(log types.Log) (*CTFExchangeRemovedAdmin, error) { - event := new(CTFExchangeRemovedAdmin) - if err := _CTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeRemovedOperatorIterator is returned from FilterRemovedOperator and is used to iterate over the raw logs and unpacked data for RemovedOperator events raised by the CTFExchange contract. -type CTFExchangeRemovedOperatorIterator struct { - Event *CTFExchangeRemovedOperator // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeRemovedOperatorIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeRemovedOperator) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeRemovedOperator) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeRemovedOperatorIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeRemovedOperatorIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeRemovedOperator represents a RemovedOperator event raised by the CTFExchange contract. -type CTFExchangeRemovedOperator struct { - RemovedOperator common.Address - Admin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterRemovedOperator is a free log retrieval operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. -// -// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) FilterRemovedOperator(opts *bind.FilterOpts, removedOperator []common.Address, admin []common.Address) (*CTFExchangeRemovedOperatorIterator, error) { - - var removedOperatorRule []interface{} - for _, removedOperatorItem := range removedOperator { - removedOperatorRule = append(removedOperatorRule, removedOperatorItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) - if err != nil { - return nil, err - } - return &CTFExchangeRemovedOperatorIterator{contract: _CTFExchange.contract, event: "RemovedOperator", logs: logs, sub: sub}, nil -} - -// WatchRemovedOperator is a free log subscription operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. -// -// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) WatchRemovedOperator(opts *bind.WatchOpts, sink chan<- *CTFExchangeRemovedOperator, removedOperator []common.Address, admin []common.Address) (event.Subscription, error) { - - var removedOperatorRule []interface{} - for _, removedOperatorItem := range removedOperator { - removedOperatorRule = append(removedOperatorRule, removedOperatorItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeRemovedOperator) - if err := _CTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseRemovedOperator is a log parse operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. -// -// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) -func (_CTFExchange *CTFExchangeFilterer) ParseRemovedOperator(log types.Log) (*CTFExchangeRemovedOperator, error) { - event := new(CTFExchangeRemovedOperator) - if err := _CTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeSafeFactoryUpdatedIterator is returned from FilterSafeFactoryUpdated and is used to iterate over the raw logs and unpacked data for SafeFactoryUpdated events raised by the CTFExchange contract. -type CTFExchangeSafeFactoryUpdatedIterator struct { - Event *CTFExchangeSafeFactoryUpdated // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeSafeFactoryUpdatedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeSafeFactoryUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeSafeFactoryUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeSafeFactoryUpdatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeSafeFactoryUpdatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeSafeFactoryUpdated represents a SafeFactoryUpdated event raised by the CTFExchange contract. -type CTFExchangeSafeFactoryUpdated struct { - OldSafeFactory common.Address - NewSafeFactory common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterSafeFactoryUpdated is a free log retrieval operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. -// -// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) -func (_CTFExchange *CTFExchangeFilterer) FilterSafeFactoryUpdated(opts *bind.FilterOpts, oldSafeFactory []common.Address, newSafeFactory []common.Address) (*CTFExchangeSafeFactoryUpdatedIterator, error) { - - var oldSafeFactoryRule []interface{} - for _, oldSafeFactoryItem := range oldSafeFactory { - oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) - } - var newSafeFactoryRule []interface{} - for _, newSafeFactoryItem := range newSafeFactory { - newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) - if err != nil { - return nil, err - } - return &CTFExchangeSafeFactoryUpdatedIterator{contract: _CTFExchange.contract, event: "SafeFactoryUpdated", logs: logs, sub: sub}, nil -} - -// WatchSafeFactoryUpdated is a free log subscription operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. -// -// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) -func (_CTFExchange *CTFExchangeFilterer) WatchSafeFactoryUpdated(opts *bind.WatchOpts, sink chan<- *CTFExchangeSafeFactoryUpdated, oldSafeFactory []common.Address, newSafeFactory []common.Address) (event.Subscription, error) { - - var oldSafeFactoryRule []interface{} - for _, oldSafeFactoryItem := range oldSafeFactory { - oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) - } - var newSafeFactoryRule []interface{} - for _, newSafeFactoryItem := range newSafeFactory { - newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeSafeFactoryUpdated) - if err := _CTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseSafeFactoryUpdated is a log parse operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. -// -// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) -func (_CTFExchange *CTFExchangeFilterer) ParseSafeFactoryUpdated(log types.Log) (*CTFExchangeSafeFactoryUpdated, error) { - event := new(CTFExchangeSafeFactoryUpdated) - if err := _CTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeTokenRegisteredIterator is returned from FilterTokenRegistered and is used to iterate over the raw logs and unpacked data for TokenRegistered events raised by the CTFExchange contract. -type CTFExchangeTokenRegisteredIterator struct { - Event *CTFExchangeTokenRegistered // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeTokenRegisteredIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeTokenRegistered) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeTokenRegistered) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeTokenRegisteredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeTokenRegisteredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeTokenRegistered represents a TokenRegistered event raised by the CTFExchange contract. -type CTFExchangeTokenRegistered struct { - Token0 *big.Int - Token1 *big.Int - ConditionId [32]byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTokenRegistered is a free log retrieval operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. -// -// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) -func (_CTFExchange *CTFExchangeFilterer) FilterTokenRegistered(opts *bind.FilterOpts, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (*CTFExchangeTokenRegisteredIterator, error) { - - var token0Rule []interface{} - for _, token0Item := range token0 { - token0Rule = append(token0Rule, token0Item) - } - var token1Rule []interface{} - for _, token1Item := range token1 { - token1Rule = append(token1Rule, token1Item) - } - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) - if err != nil { - return nil, err - } - return &CTFExchangeTokenRegisteredIterator{contract: _CTFExchange.contract, event: "TokenRegistered", logs: logs, sub: sub}, nil -} - -// WatchTokenRegistered is a free log subscription operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. -// -// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) -func (_CTFExchange *CTFExchangeFilterer) WatchTokenRegistered(opts *bind.WatchOpts, sink chan<- *CTFExchangeTokenRegistered, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (event.Subscription, error) { - - var token0Rule []interface{} - for _, token0Item := range token0 { - token0Rule = append(token0Rule, token0Item) - } - var token1Rule []interface{} - for _, token1Item := range token1 { - token1Rule = append(token1Rule, token1Item) - } - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeTokenRegistered) - if err := _CTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseTokenRegistered is a log parse operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. -// -// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) -func (_CTFExchange *CTFExchangeFilterer) ParseTokenRegistered(log types.Log) (*CTFExchangeTokenRegistered, error) { - event := new(CTFExchangeTokenRegistered) - if err := _CTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeTradingPausedIterator is returned from FilterTradingPaused and is used to iterate over the raw logs and unpacked data for TradingPaused events raised by the CTFExchange contract. -type CTFExchangeTradingPausedIterator struct { - Event *CTFExchangeTradingPaused // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeTradingPausedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeTradingPaused) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeTradingPaused) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeTradingPausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeTradingPausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeTradingPaused represents a TradingPaused event raised by the CTFExchange contract. -type CTFExchangeTradingPaused struct { - Pauser common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTradingPaused is a free log retrieval operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. -// -// Solidity: event TradingPaused(address indexed pauser) -func (_CTFExchange *CTFExchangeFilterer) FilterTradingPaused(opts *bind.FilterOpts, pauser []common.Address) (*CTFExchangeTradingPausedIterator, error) { - - var pauserRule []interface{} - for _, pauserItem := range pauser { - pauserRule = append(pauserRule, pauserItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "TradingPaused", pauserRule) - if err != nil { - return nil, err - } - return &CTFExchangeTradingPausedIterator{contract: _CTFExchange.contract, event: "TradingPaused", logs: logs, sub: sub}, nil -} - -// WatchTradingPaused is a free log subscription operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. -// -// Solidity: event TradingPaused(address indexed pauser) -func (_CTFExchange *CTFExchangeFilterer) WatchTradingPaused(opts *bind.WatchOpts, sink chan<- *CTFExchangeTradingPaused, pauser []common.Address) (event.Subscription, error) { - - var pauserRule []interface{} - for _, pauserItem := range pauser { - pauserRule = append(pauserRule, pauserItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "TradingPaused", pauserRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeTradingPaused) - if err := _CTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseTradingPaused is a log parse operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. -// -// Solidity: event TradingPaused(address indexed pauser) -func (_CTFExchange *CTFExchangeFilterer) ParseTradingPaused(log types.Log) (*CTFExchangeTradingPaused, error) { - event := new(CTFExchangeTradingPaused) - if err := _CTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CTFExchangeTradingUnpausedIterator is returned from FilterTradingUnpaused and is used to iterate over the raw logs and unpacked data for TradingUnpaused events raised by the CTFExchange contract. -type CTFExchangeTradingUnpausedIterator struct { - Event *CTFExchangeTradingUnpaused // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CTFExchangeTradingUnpausedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CTFExchangeTradingUnpaused) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CTFExchangeTradingUnpaused) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CTFExchangeTradingUnpausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CTFExchangeTradingUnpausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CTFExchangeTradingUnpaused represents a TradingUnpaused event raised by the CTFExchange contract. -type CTFExchangeTradingUnpaused struct { - Pauser common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTradingUnpaused is a free log retrieval operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. -// -// Solidity: event TradingUnpaused(address indexed pauser) -func (_CTFExchange *CTFExchangeFilterer) FilterTradingUnpaused(opts *bind.FilterOpts, pauser []common.Address) (*CTFExchangeTradingUnpausedIterator, error) { - - var pauserRule []interface{} - for _, pauserItem := range pauser { - pauserRule = append(pauserRule, pauserItem) - } - - logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "TradingUnpaused", pauserRule) - if err != nil { - return nil, err - } - return &CTFExchangeTradingUnpausedIterator{contract: _CTFExchange.contract, event: "TradingUnpaused", logs: logs, sub: sub}, nil -} - -// WatchTradingUnpaused is a free log subscription operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. -// -// Solidity: event TradingUnpaused(address indexed pauser) -func (_CTFExchange *CTFExchangeFilterer) WatchTradingUnpaused(opts *bind.WatchOpts, sink chan<- *CTFExchangeTradingUnpaused, pauser []common.Address) (event.Subscription, error) { - - var pauserRule []interface{} - for _, pauserItem := range pauser { - pauserRule = append(pauserRule, pauserItem) - } - - logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "TradingUnpaused", pauserRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CTFExchangeTradingUnpaused) - if err := _CTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseTradingUnpaused is a log parse operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. -// -// Solidity: event TradingUnpaused(address indexed pauser) -func (_CTFExchange *CTFExchangeFilterer) ParseTradingUnpaused(log types.Log) (*CTFExchangeTradingUnpaused, error) { - event := new(CTFExchangeTradingUnpaused) - if err := _CTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go b/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go deleted file mode 100644 index f453d9e2..00000000 --- a/provider/ethereum/contract/polymarket/contract_neg_risk_ctf_exchange.go +++ /dev/null @@ -1,3543 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package polymarket - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// NegRiskCTFExchangeMetaData contains all meta data concerning the NegRiskCTFExchange contract. -var NegRiskCTFExchangeMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_ctf\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_negRiskAdapter\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_proxyFactory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_safeFactory\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FeeTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidComplement\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenId\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MakingGtRemaining\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MismatchedTokenIds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCrossing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOperator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderFilledOrCancelled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLittleTokensReceived\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"FeeCharged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newAdminAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOperatorAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderCancelled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"OrderFilled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"takerOrderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"takerOrderMaker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"}],\"name\":\"OrdersMatched\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldProxyFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProxyFactory\",\"type\":\"address\"}],\"name\":\"ProxyFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedAdmin\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedOperator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldSafeFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newSafeFactory\",\"type\":\"address\"}],\"name\":\"SafeFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token0\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"TokenRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingUnpaused\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"name\":\"addAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator_\",\"type\":\"address\"}],\"name\":\"addOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"admins\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"cancelOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"cancelOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"domainSeparator\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"fillAmount\",\"type\":\"uint256\"}],\"name\":\"fillOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"fillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"fillOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateral\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getComplement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCtf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getMaxFeeRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"getOrderStatus\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"internalType\":\"structOrderStatus\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPolyProxyFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getPolyProxyWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getProxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getSafeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isAdmin\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"isValidNonce\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"takerOrder\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"makerOrders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"takerFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"makerFillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"matchOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"operators\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"orderStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parentCollectionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"registerToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"removeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"removeOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOperatorRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"safeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProxyFactory\",\"type\":\"address\"}],\"name\":\"setProxyFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newSafeFactory\",\"type\":\"address\"}],\"name\":\"setSafeFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"}],\"name\":\"validateComplement\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrder\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrderSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"validateTokenId\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", -} - -// NegRiskCTFExchangeABI is the input ABI used to generate the binding from. -// Deprecated: Use NegRiskCTFExchangeMetaData.ABI instead. -var NegRiskCTFExchangeABI = NegRiskCTFExchangeMetaData.ABI - -// NegRiskCTFExchange is an auto generated Go binding around an Ethereum contract. -type NegRiskCTFExchange struct { - NegRiskCTFExchangeCaller // Read-only binding to the contract - NegRiskCTFExchangeTransactor // Write-only binding to the contract - NegRiskCTFExchangeFilterer // Log filterer for contract events -} - -// NegRiskCTFExchangeCaller is an auto generated read-only Go binding around an Ethereum contract. -type NegRiskCTFExchangeCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// NegRiskCTFExchangeTransactor is an auto generated write-only Go binding around an Ethereum contract. -type NegRiskCTFExchangeTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// NegRiskCTFExchangeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type NegRiskCTFExchangeFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// NegRiskCTFExchangeSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type NegRiskCTFExchangeSession struct { - Contract *NegRiskCTFExchange // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// NegRiskCTFExchangeCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type NegRiskCTFExchangeCallerSession struct { - Contract *NegRiskCTFExchangeCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// NegRiskCTFExchangeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type NegRiskCTFExchangeTransactorSession struct { - Contract *NegRiskCTFExchangeTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// NegRiskCTFExchangeRaw is an auto generated low-level Go binding around an Ethereum contract. -type NegRiskCTFExchangeRaw struct { - Contract *NegRiskCTFExchange // Generic contract binding to access the raw methods on -} - -// NegRiskCTFExchangeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type NegRiskCTFExchangeCallerRaw struct { - Contract *NegRiskCTFExchangeCaller // Generic read-only contract binding to access the raw methods on -} - -// NegRiskCTFExchangeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type NegRiskCTFExchangeTransactorRaw struct { - Contract *NegRiskCTFExchangeTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewNegRiskCTFExchange creates a new instance of NegRiskCTFExchange, bound to a specific deployed contract. -func NewNegRiskCTFExchange(address common.Address, backend bind.ContractBackend) (*NegRiskCTFExchange, error) { - contract, err := bindNegRiskCTFExchange(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &NegRiskCTFExchange{NegRiskCTFExchangeCaller: NegRiskCTFExchangeCaller{contract: contract}, NegRiskCTFExchangeTransactor: NegRiskCTFExchangeTransactor{contract: contract}, NegRiskCTFExchangeFilterer: NegRiskCTFExchangeFilterer{contract: contract}}, nil -} - -// NewNegRiskCTFExchangeCaller creates a new read-only instance of NegRiskCTFExchange, bound to a specific deployed contract. -func NewNegRiskCTFExchangeCaller(address common.Address, caller bind.ContractCaller) (*NegRiskCTFExchangeCaller, error) { - contract, err := bindNegRiskCTFExchange(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeCaller{contract: contract}, nil -} - -// NewNegRiskCTFExchangeTransactor creates a new write-only instance of NegRiskCTFExchange, bound to a specific deployed contract. -func NewNegRiskCTFExchangeTransactor(address common.Address, transactor bind.ContractTransactor) (*NegRiskCTFExchangeTransactor, error) { - contract, err := bindNegRiskCTFExchange(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeTransactor{contract: contract}, nil -} - -// NewNegRiskCTFExchangeFilterer creates a new log filterer instance of NegRiskCTFExchange, bound to a specific deployed contract. -func NewNegRiskCTFExchangeFilterer(address common.Address, filterer bind.ContractFilterer) (*NegRiskCTFExchangeFilterer, error) { - contract, err := bindNegRiskCTFExchange(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeFilterer{contract: contract}, nil -} - -// bindNegRiskCTFExchange binds a generic wrapper to an already deployed contract. -func bindNegRiskCTFExchange(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := NegRiskCTFExchangeMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_NegRiskCTFExchange *NegRiskCTFExchangeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _NegRiskCTFExchange.Contract.NegRiskCTFExchangeCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_NegRiskCTFExchange *NegRiskCTFExchangeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.NegRiskCTFExchangeTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_NegRiskCTFExchange *NegRiskCTFExchangeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.NegRiskCTFExchangeTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _NegRiskCTFExchange.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.contract.Transact(opts, method, params...) -} - -// Admins is a free data retrieval call binding the contract method 0x429b62e5. -// -// Solidity: function admins(address ) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Admins(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "admins", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Admins is a free data retrieval call binding the contract method 0x429b62e5. -// -// Solidity: function admins(address ) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Admins(arg0 common.Address) (*big.Int, error) { - return _NegRiskCTFExchange.Contract.Admins(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// Admins is a free data retrieval call binding the contract method 0x429b62e5. -// -// Solidity: function admins(address ) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Admins(arg0 common.Address) (*big.Int, error) { - return _NegRiskCTFExchange.Contract.Admins(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "domainSeparator") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) DomainSeparator() ([32]byte, error) { - return _NegRiskCTFExchange.Contract.DomainSeparator(&_NegRiskCTFExchange.CallOpts) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) DomainSeparator() ([32]byte, error) { - return _NegRiskCTFExchange.Contract.DomainSeparator(&_NegRiskCTFExchange.CallOpts) -} - -// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. -// -// Solidity: function getCollateral() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetCollateral(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getCollateral") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. -// -// Solidity: function getCollateral() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetCollateral() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetCollateral(&_NegRiskCTFExchange.CallOpts) -} - -// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. -// -// Solidity: function getCollateral() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetCollateral() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetCollateral(&_NegRiskCTFExchange.CallOpts) -} - -// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. -// -// Solidity: function getComplement(uint256 token) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetComplement(opts *bind.CallOpts, token *big.Int) (*big.Int, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getComplement", token) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. -// -// Solidity: function getComplement(uint256 token) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetComplement(token *big.Int) (*big.Int, error) { - return _NegRiskCTFExchange.Contract.GetComplement(&_NegRiskCTFExchange.CallOpts, token) -} - -// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. -// -// Solidity: function getComplement(uint256 token) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetComplement(token *big.Int) (*big.Int, error) { - return _NegRiskCTFExchange.Contract.GetComplement(&_NegRiskCTFExchange.CallOpts, token) -} - -// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. -// -// Solidity: function getConditionId(uint256 token) view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetConditionId(opts *bind.CallOpts, token *big.Int) ([32]byte, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getConditionId", token) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. -// -// Solidity: function getConditionId(uint256 token) view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetConditionId(token *big.Int) ([32]byte, error) { - return _NegRiskCTFExchange.Contract.GetConditionId(&_NegRiskCTFExchange.CallOpts, token) -} - -// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. -// -// Solidity: function getConditionId(uint256 token) view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetConditionId(token *big.Int) ([32]byte, error) { - return _NegRiskCTFExchange.Contract.GetConditionId(&_NegRiskCTFExchange.CallOpts, token) -} - -// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. -// -// Solidity: function getCtf() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetCtf(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getCtf") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. -// -// Solidity: function getCtf() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetCtf() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetCtf(&_NegRiskCTFExchange.CallOpts) -} - -// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. -// -// Solidity: function getCtf() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetCtf() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetCtf(&_NegRiskCTFExchange.CallOpts) -} - -// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. -// -// Solidity: function getMaxFeeRate() pure returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetMaxFeeRate(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getMaxFeeRate") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. -// -// Solidity: function getMaxFeeRate() pure returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetMaxFeeRate() (*big.Int, error) { - return _NegRiskCTFExchange.Contract.GetMaxFeeRate(&_NegRiskCTFExchange.CallOpts) -} - -// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. -// -// Solidity: function getMaxFeeRate() pure returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetMaxFeeRate() (*big.Int, error) { - return _NegRiskCTFExchange.Contract.GetMaxFeeRate(&_NegRiskCTFExchange.CallOpts) -} - -// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. -// -// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetOrderStatus(opts *bind.CallOpts, orderHash [32]byte) (OrderStatus, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getOrderStatus", orderHash) - - if err != nil { - return *new(OrderStatus), err - } - - out0 := *abi.ConvertType(out[0], new(OrderStatus)).(*OrderStatus) - - return out0, err - -} - -// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. -// -// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { - return _NegRiskCTFExchange.Contract.GetOrderStatus(&_NegRiskCTFExchange.CallOpts, orderHash) -} - -// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. -// -// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { - return _NegRiskCTFExchange.Contract.GetOrderStatus(&_NegRiskCTFExchange.CallOpts, orderHash) -} - -// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. -// -// Solidity: function getPolyProxyFactoryImplementation() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetPolyProxyFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getPolyProxyFactoryImplementation") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. -// -// Solidity: function getPolyProxyFactoryImplementation() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetPolyProxyFactoryImplementation() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetPolyProxyFactoryImplementation(&_NegRiskCTFExchange.CallOpts) -} - -// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. -// -// Solidity: function getPolyProxyFactoryImplementation() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetPolyProxyFactoryImplementation() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetPolyProxyFactoryImplementation(&_NegRiskCTFExchange.CallOpts) -} - -// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. -// -// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetPolyProxyWalletAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getPolyProxyWalletAddress", _addr) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. -// -// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetPolyProxyWalletAddress(&_NegRiskCTFExchange.CallOpts, _addr) -} - -// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. -// -// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetPolyProxyWalletAddress(&_NegRiskCTFExchange.CallOpts, _addr) -} - -// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. -// -// Solidity: function getProxyFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetProxyFactory(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getProxyFactory") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. -// -// Solidity: function getProxyFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetProxyFactory() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetProxyFactory(&_NegRiskCTFExchange.CallOpts) -} - -// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. -// -// Solidity: function getProxyFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetProxyFactory() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetProxyFactory(&_NegRiskCTFExchange.CallOpts) -} - -// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. -// -// Solidity: function getSafeAddress(address _addr) view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetSafeAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getSafeAddress", _addr) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. -// -// Solidity: function getSafeAddress(address _addr) view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetSafeAddress(_addr common.Address) (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetSafeAddress(&_NegRiskCTFExchange.CallOpts, _addr) -} - -// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. -// -// Solidity: function getSafeAddress(address _addr) view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetSafeAddress(_addr common.Address) (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetSafeAddress(&_NegRiskCTFExchange.CallOpts, _addr) -} - -// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. -// -// Solidity: function getSafeFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetSafeFactory(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getSafeFactory") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. -// -// Solidity: function getSafeFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetSafeFactory() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetSafeFactory(&_NegRiskCTFExchange.CallOpts) -} - -// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. -// -// Solidity: function getSafeFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetSafeFactory() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetSafeFactory(&_NegRiskCTFExchange.CallOpts) -} - -// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. -// -// Solidity: function getSafeFactoryImplementation() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) GetSafeFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "getSafeFactoryImplementation") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. -// -// Solidity: function getSafeFactoryImplementation() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) GetSafeFactoryImplementation() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetSafeFactoryImplementation(&_NegRiskCTFExchange.CallOpts) -} - -// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. -// -// Solidity: function getSafeFactoryImplementation() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) GetSafeFactoryImplementation() (common.Address, error) { - return _NegRiskCTFExchange.Contract.GetSafeFactoryImplementation(&_NegRiskCTFExchange.CallOpts) -} - -// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. -// -// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) HashOrder(opts *bind.CallOpts, order Order) ([32]byte, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "hashOrder", order) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. -// -// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) HashOrder(order Order) ([32]byte, error) { - return _NegRiskCTFExchange.Contract.HashOrder(&_NegRiskCTFExchange.CallOpts, order) -} - -// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. -// -// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) HashOrder(order Order) ([32]byte, error) { - return _NegRiskCTFExchange.Contract.HashOrder(&_NegRiskCTFExchange.CallOpts, order) -} - -// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. -// -// Solidity: function isAdmin(address usr) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) IsAdmin(opts *bind.CallOpts, usr common.Address) (bool, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "isAdmin", usr) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. -// -// Solidity: function isAdmin(address usr) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) IsAdmin(usr common.Address) (bool, error) { - return _NegRiskCTFExchange.Contract.IsAdmin(&_NegRiskCTFExchange.CallOpts, usr) -} - -// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. -// -// Solidity: function isAdmin(address usr) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) IsAdmin(usr common.Address) (bool, error) { - return _NegRiskCTFExchange.Contract.IsAdmin(&_NegRiskCTFExchange.CallOpts, usr) -} - -// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. -// -// Solidity: function isOperator(address usr) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) IsOperator(opts *bind.CallOpts, usr common.Address) (bool, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "isOperator", usr) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. -// -// Solidity: function isOperator(address usr) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) IsOperator(usr common.Address) (bool, error) { - return _NegRiskCTFExchange.Contract.IsOperator(&_NegRiskCTFExchange.CallOpts, usr) -} - -// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. -// -// Solidity: function isOperator(address usr) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) IsOperator(usr common.Address) (bool, error) { - return _NegRiskCTFExchange.Contract.IsOperator(&_NegRiskCTFExchange.CallOpts, usr) -} - -// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. -// -// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) IsValidNonce(opts *bind.CallOpts, usr common.Address, nonce *big.Int) (bool, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "isValidNonce", usr, nonce) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. -// -// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { - return _NegRiskCTFExchange.Contract.IsValidNonce(&_NegRiskCTFExchange.CallOpts, usr, nonce) -} - -// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. -// -// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { - return _NegRiskCTFExchange.Contract.IsValidNonce(&_NegRiskCTFExchange.CallOpts, usr, nonce) -} - -// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. -// -// Solidity: function nonces(address ) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "nonces", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. -// -// Solidity: function nonces(address ) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Nonces(arg0 common.Address) (*big.Int, error) { - return _NegRiskCTFExchange.Contract.Nonces(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. -// -// Solidity: function nonces(address ) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Nonces(arg0 common.Address) (*big.Int, error) { - return _NegRiskCTFExchange.Contract.Nonces(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. -// -// Solidity: function operators(address ) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Operators(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "operators", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. -// -// Solidity: function operators(address ) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Operators(arg0 common.Address) (*big.Int, error) { - return _NegRiskCTFExchange.Contract.Operators(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. -// -// Solidity: function operators(address ) view returns(uint256) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Operators(arg0 common.Address) (*big.Int, error) { - return _NegRiskCTFExchange.Contract.Operators(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. -// -// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) OrderStatus(opts *bind.CallOpts, arg0 [32]byte) (struct { - IsFilledOrCancelled bool - Remaining *big.Int -}, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "orderStatus", arg0) - - outstruct := new(struct { - IsFilledOrCancelled bool - Remaining *big.Int - }) - if err != nil { - return *outstruct, err - } - - outstruct.IsFilledOrCancelled = *abi.ConvertType(out[0], new(bool)).(*bool) - outstruct.Remaining = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. -// -// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) OrderStatus(arg0 [32]byte) (struct { - IsFilledOrCancelled bool - Remaining *big.Int -}, error) { - return _NegRiskCTFExchange.Contract.OrderStatus(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. -// -// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) OrderStatus(arg0 [32]byte) (struct { - IsFilledOrCancelled bool - Remaining *big.Int -}, error) { - return _NegRiskCTFExchange.Contract.OrderStatus(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. -// -// Solidity: function parentCollectionId() view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ParentCollectionId(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "parentCollectionId") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. -// -// Solidity: function parentCollectionId() view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ParentCollectionId() ([32]byte, error) { - return _NegRiskCTFExchange.Contract.ParentCollectionId(&_NegRiskCTFExchange.CallOpts) -} - -// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. -// -// Solidity: function parentCollectionId() view returns(bytes32) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ParentCollectionId() ([32]byte, error) { - return _NegRiskCTFExchange.Contract.ParentCollectionId(&_NegRiskCTFExchange.CallOpts) -} - -// Paused is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Paused(opts *bind.CallOpts) (bool, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "paused") - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// Paused is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Paused() (bool, error) { - return _NegRiskCTFExchange.Contract.Paused(&_NegRiskCTFExchange.CallOpts) -} - -// Paused is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Paused() (bool, error) { - return _NegRiskCTFExchange.Contract.Paused(&_NegRiskCTFExchange.CallOpts) -} - -// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. -// -// Solidity: function proxyFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ProxyFactory(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "proxyFactory") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. -// -// Solidity: function proxyFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ProxyFactory() (common.Address, error) { - return _NegRiskCTFExchange.Contract.ProxyFactory(&_NegRiskCTFExchange.CallOpts) -} - -// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. -// -// Solidity: function proxyFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ProxyFactory() (common.Address, error) { - return _NegRiskCTFExchange.Contract.ProxyFactory(&_NegRiskCTFExchange.CallOpts) -} - -// Registry is a free data retrieval call binding the contract method 0x5893253c. -// -// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) Registry(opts *bind.CallOpts, arg0 *big.Int) (struct { - Complement *big.Int - ConditionId [32]byte -}, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "registry", arg0) - - outstruct := new(struct { - Complement *big.Int - ConditionId [32]byte - }) - if err != nil { - return *outstruct, err - } - - outstruct.Complement = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.ConditionId = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) - - return *outstruct, err - -} - -// Registry is a free data retrieval call binding the contract method 0x5893253c. -// -// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) Registry(arg0 *big.Int) (struct { - Complement *big.Int - ConditionId [32]byte -}, error) { - return _NegRiskCTFExchange.Contract.Registry(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// Registry is a free data retrieval call binding the contract method 0x5893253c. -// -// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) Registry(arg0 *big.Int) (struct { - Complement *big.Int - ConditionId [32]byte -}, error) { - return _NegRiskCTFExchange.Contract.Registry(&_NegRiskCTFExchange.CallOpts, arg0) -} - -// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. -// -// Solidity: function safeFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) SafeFactory(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "safeFactory") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. -// -// Solidity: function safeFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) SafeFactory() (common.Address, error) { - return _NegRiskCTFExchange.Contract.SafeFactory(&_NegRiskCTFExchange.CallOpts) -} - -// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. -// -// Solidity: function safeFactory() view returns(address) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) SafeFactory() (common.Address, error) { - return _NegRiskCTFExchange.Contract.SafeFactory(&_NegRiskCTFExchange.CallOpts) -} - -// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. -// -// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "supportsInterface", interfaceId) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. -// -// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) SupportsInterface(interfaceId [4]byte) (bool, error) { - return _NegRiskCTFExchange.Contract.SupportsInterface(&_NegRiskCTFExchange.CallOpts, interfaceId) -} - -// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. -// -// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { - return _NegRiskCTFExchange.Contract.SupportsInterface(&_NegRiskCTFExchange.CallOpts, interfaceId) -} - -// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. -// -// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ValidateComplement(opts *bind.CallOpts, token *big.Int, complement *big.Int) error { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "validateComplement", token, complement) - - if err != nil { - return err - } - - return err - -} - -// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. -// -// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ValidateComplement(token *big.Int, complement *big.Int) error { - return _NegRiskCTFExchange.Contract.ValidateComplement(&_NegRiskCTFExchange.CallOpts, token, complement) -} - -// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. -// -// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ValidateComplement(token *big.Int, complement *big.Int) error { - return _NegRiskCTFExchange.Contract.ValidateComplement(&_NegRiskCTFExchange.CallOpts, token, complement) -} - -// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. -// -// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ValidateOrder(opts *bind.CallOpts, order Order) error { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "validateOrder", order) - - if err != nil { - return err - } - - return err - -} - -// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. -// -// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ValidateOrder(order Order) error { - return _NegRiskCTFExchange.Contract.ValidateOrder(&_NegRiskCTFExchange.CallOpts, order) -} - -// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. -// -// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ValidateOrder(order Order) error { - return _NegRiskCTFExchange.Contract.ValidateOrder(&_NegRiskCTFExchange.CallOpts, order) -} - -// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. -// -// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ValidateOrderSignature(opts *bind.CallOpts, orderHash [32]byte, order Order) error { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "validateOrderSignature", orderHash, order) - - if err != nil { - return err - } - - return err - -} - -// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. -// -// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { - return _NegRiskCTFExchange.Contract.ValidateOrderSignature(&_NegRiskCTFExchange.CallOpts, orderHash, order) -} - -// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. -// -// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { - return _NegRiskCTFExchange.Contract.ValidateOrderSignature(&_NegRiskCTFExchange.CallOpts, orderHash, order) -} - -// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. -// -// Solidity: function validateTokenId(uint256 tokenId) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeCaller) ValidateTokenId(opts *bind.CallOpts, tokenId *big.Int) error { - var out []interface{} - err := _NegRiskCTFExchange.contract.Call(opts, &out, "validateTokenId", tokenId) - - if err != nil { - return err - } - - return err - -} - -// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. -// -// Solidity: function validateTokenId(uint256 tokenId) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) ValidateTokenId(tokenId *big.Int) error { - return _NegRiskCTFExchange.Contract.ValidateTokenId(&_NegRiskCTFExchange.CallOpts, tokenId) -} - -// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. -// -// Solidity: function validateTokenId(uint256 tokenId) view returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeCallerSession) ValidateTokenId(tokenId *big.Int) error { - return _NegRiskCTFExchange.Contract.ValidateTokenId(&_NegRiskCTFExchange.CallOpts, tokenId) -} - -// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. -// -// Solidity: function addAdmin(address admin_) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) AddAdmin(opts *bind.TransactOpts, admin_ common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "addAdmin", admin_) -} - -// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. -// -// Solidity: function addAdmin(address admin_) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.AddAdmin(&_NegRiskCTFExchange.TransactOpts, admin_) -} - -// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. -// -// Solidity: function addAdmin(address admin_) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.AddAdmin(&_NegRiskCTFExchange.TransactOpts, admin_) -} - -// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. -// -// Solidity: function addOperator(address operator_) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) AddOperator(opts *bind.TransactOpts, operator_ common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "addOperator", operator_) -} - -// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. -// -// Solidity: function addOperator(address operator_) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.AddOperator(&_NegRiskCTFExchange.TransactOpts, operator_) -} - -// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. -// -// Solidity: function addOperator(address operator_) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.AddOperator(&_NegRiskCTFExchange.TransactOpts, operator_) -} - -// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. -// -// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) CancelOrder(opts *bind.TransactOpts, order Order) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "cancelOrder", order) -} - -// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. -// -// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) CancelOrder(order Order) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.CancelOrder(&_NegRiskCTFExchange.TransactOpts, order) -} - -// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. -// -// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) CancelOrder(order Order) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.CancelOrder(&_NegRiskCTFExchange.TransactOpts, order) -} - -// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. -// -// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) CancelOrders(opts *bind.TransactOpts, orders []Order) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "cancelOrders", orders) -} - -// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. -// -// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) CancelOrders(orders []Order) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.CancelOrders(&_NegRiskCTFExchange.TransactOpts, orders) -} - -// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. -// -// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) CancelOrders(orders []Order) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.CancelOrders(&_NegRiskCTFExchange.TransactOpts, orders) -} - -// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. -// -// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) FillOrder(opts *bind.TransactOpts, order Order, fillAmount *big.Int) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "fillOrder", order, fillAmount) -} - -// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. -// -// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.FillOrder(&_NegRiskCTFExchange.TransactOpts, order, fillAmount) -} - -// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. -// -// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.FillOrder(&_NegRiskCTFExchange.TransactOpts, order, fillAmount) -} - -// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. -// -// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) FillOrders(opts *bind.TransactOpts, orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "fillOrders", orders, fillAmounts) -} - -// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. -// -// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.FillOrders(&_NegRiskCTFExchange.TransactOpts, orders, fillAmounts) -} - -// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. -// -// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.FillOrders(&_NegRiskCTFExchange.TransactOpts, orders, fillAmounts) -} - -// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. -// -// Solidity: function incrementNonce() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) IncrementNonce(opts *bind.TransactOpts) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "incrementNonce") -} - -// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. -// -// Solidity: function incrementNonce() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) IncrementNonce() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.IncrementNonce(&_NegRiskCTFExchange.TransactOpts) -} - -// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. -// -// Solidity: function incrementNonce() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) IncrementNonce() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.IncrementNonce(&_NegRiskCTFExchange.TransactOpts) -} - -// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. -// -// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) MatchOrders(opts *bind.TransactOpts, takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "matchOrders", takerOrder, makerOrders, takerFillAmount, makerFillAmounts) -} - -// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. -// -// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.MatchOrders(&_NegRiskCTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) -} - -// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. -// -// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.MatchOrders(&_NegRiskCTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) -} - -// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. -// -// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "onERC1155BatchReceived", arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. -// -// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.OnERC1155BatchReceived(&_NegRiskCTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. -// -// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.OnERC1155BatchReceived(&_NegRiskCTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. -// -// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "onERC1155Received", arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. -// -// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.OnERC1155Received(&_NegRiskCTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) -} - -// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. -// -// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.OnERC1155Received(&_NegRiskCTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) -} - -// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. -// -// Solidity: function pauseTrading() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) PauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "pauseTrading") -} - -// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. -// -// Solidity: function pauseTrading() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) PauseTrading() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.PauseTrading(&_NegRiskCTFExchange.TransactOpts) -} - -// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. -// -// Solidity: function pauseTrading() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) PauseTrading() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.PauseTrading(&_NegRiskCTFExchange.TransactOpts) -} - -// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. -// -// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RegisterToken(opts *bind.TransactOpts, token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "registerToken", token, complement, conditionId) -} - -// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. -// -// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RegisterToken(&_NegRiskCTFExchange.TransactOpts, token, complement, conditionId) -} - -// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. -// -// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RegisterToken(&_NegRiskCTFExchange.TransactOpts, token, complement, conditionId) -} - -// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. -// -// Solidity: function removeAdmin(address admin) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RemoveAdmin(opts *bind.TransactOpts, admin common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "removeAdmin", admin) -} - -// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. -// -// Solidity: function removeAdmin(address admin) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RemoveAdmin(&_NegRiskCTFExchange.TransactOpts, admin) -} - -// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. -// -// Solidity: function removeAdmin(address admin) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RemoveAdmin(&_NegRiskCTFExchange.TransactOpts, admin) -} - -// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. -// -// Solidity: function removeOperator(address operator) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RemoveOperator(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "removeOperator", operator) -} - -// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. -// -// Solidity: function removeOperator(address operator) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RemoveOperator(&_NegRiskCTFExchange.TransactOpts, operator) -} - -// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. -// -// Solidity: function removeOperator(address operator) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RemoveOperator(&_NegRiskCTFExchange.TransactOpts, operator) -} - -// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. -// -// Solidity: function renounceAdminRole() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RenounceAdminRole(opts *bind.TransactOpts) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "renounceAdminRole") -} - -// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. -// -// Solidity: function renounceAdminRole() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RenounceAdminRole() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RenounceAdminRole(&_NegRiskCTFExchange.TransactOpts) -} - -// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. -// -// Solidity: function renounceAdminRole() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RenounceAdminRole() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RenounceAdminRole(&_NegRiskCTFExchange.TransactOpts) -} - -// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. -// -// Solidity: function renounceOperatorRole() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) RenounceOperatorRole(opts *bind.TransactOpts) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "renounceOperatorRole") -} - -// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. -// -// Solidity: function renounceOperatorRole() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) RenounceOperatorRole() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RenounceOperatorRole(&_NegRiskCTFExchange.TransactOpts) -} - -// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. -// -// Solidity: function renounceOperatorRole() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) RenounceOperatorRole() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.RenounceOperatorRole(&_NegRiskCTFExchange.TransactOpts) -} - -// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. -// -// Solidity: function setProxyFactory(address _newProxyFactory) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) SetProxyFactory(opts *bind.TransactOpts, _newProxyFactory common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "setProxyFactory", _newProxyFactory) -} - -// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. -// -// Solidity: function setProxyFactory(address _newProxyFactory) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.SetProxyFactory(&_NegRiskCTFExchange.TransactOpts, _newProxyFactory) -} - -// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. -// -// Solidity: function setProxyFactory(address _newProxyFactory) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.SetProxyFactory(&_NegRiskCTFExchange.TransactOpts, _newProxyFactory) -} - -// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. -// -// Solidity: function setSafeFactory(address _newSafeFactory) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) SetSafeFactory(opts *bind.TransactOpts, _newSafeFactory common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "setSafeFactory", _newSafeFactory) -} - -// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. -// -// Solidity: function setSafeFactory(address _newSafeFactory) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.SetSafeFactory(&_NegRiskCTFExchange.TransactOpts, _newSafeFactory) -} - -// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. -// -// Solidity: function setSafeFactory(address _newSafeFactory) returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.SetSafeFactory(&_NegRiskCTFExchange.TransactOpts, _newSafeFactory) -} - -// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. -// -// Solidity: function unpauseTrading() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactor) UnpauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { - return _NegRiskCTFExchange.contract.Transact(opts, "unpauseTrading") -} - -// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. -// -// Solidity: function unpauseTrading() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeSession) UnpauseTrading() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.UnpauseTrading(&_NegRiskCTFExchange.TransactOpts) -} - -// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. -// -// Solidity: function unpauseTrading() returns() -func (_NegRiskCTFExchange *NegRiskCTFExchangeTransactorSession) UnpauseTrading() (*types.Transaction, error) { - return _NegRiskCTFExchange.Contract.UnpauseTrading(&_NegRiskCTFExchange.TransactOpts) -} - -// NegRiskCTFExchangeFeeChargedIterator is returned from FilterFeeCharged and is used to iterate over the raw logs and unpacked data for FeeCharged events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeFeeChargedIterator struct { - Event *NegRiskCTFExchangeFeeCharged // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeFeeChargedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeFeeCharged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeFeeCharged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeFeeChargedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeFeeChargedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeFeeCharged represents a FeeCharged event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeFeeCharged struct { - Receiver common.Address - TokenId *big.Int - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterFeeCharged is a free log retrieval operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. -// -// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterFeeCharged(opts *bind.FilterOpts, receiver []common.Address) (*NegRiskCTFExchangeFeeChargedIterator, error) { - - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "FeeCharged", receiverRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeFeeChargedIterator{contract: _NegRiskCTFExchange.contract, event: "FeeCharged", logs: logs, sub: sub}, nil -} - -// WatchFeeCharged is a free log subscription operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. -// -// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchFeeCharged(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeFeeCharged, receiver []common.Address) (event.Subscription, error) { - - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "FeeCharged", receiverRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeFeeCharged) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseFeeCharged is a log parse operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. -// -// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseFeeCharged(log types.Log) (*NegRiskCTFExchangeFeeCharged, error) { - event := new(NegRiskCTFExchangeFeeCharged) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeNewAdminIterator is returned from FilterNewAdmin and is used to iterate over the raw logs and unpacked data for NewAdmin events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeNewAdminIterator struct { - Event *NegRiskCTFExchangeNewAdmin // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeNewAdminIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeNewAdmin) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeNewAdmin) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeNewAdminIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeNewAdminIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeNewAdmin represents a NewAdmin event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeNewAdmin struct { - NewAdminAddress common.Address - Admin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterNewAdmin is a free log retrieval operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. -// -// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterNewAdmin(opts *bind.FilterOpts, newAdminAddress []common.Address, admin []common.Address) (*NegRiskCTFExchangeNewAdminIterator, error) { - - var newAdminAddressRule []interface{} - for _, newAdminAddressItem := range newAdminAddress { - newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeNewAdminIterator{contract: _NegRiskCTFExchange.contract, event: "NewAdmin", logs: logs, sub: sub}, nil -} - -// WatchNewAdmin is a free log subscription operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. -// -// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchNewAdmin(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeNewAdmin, newAdminAddress []common.Address, admin []common.Address) (event.Subscription, error) { - - var newAdminAddressRule []interface{} - for _, newAdminAddressItem := range newAdminAddress { - newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeNewAdmin) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseNewAdmin is a log parse operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. -// -// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseNewAdmin(log types.Log) (*NegRiskCTFExchangeNewAdmin, error) { - event := new(NegRiskCTFExchangeNewAdmin) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeNewOperatorIterator is returned from FilterNewOperator and is used to iterate over the raw logs and unpacked data for NewOperator events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeNewOperatorIterator struct { - Event *NegRiskCTFExchangeNewOperator // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeNewOperatorIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeNewOperator) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeNewOperator) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeNewOperatorIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeNewOperatorIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeNewOperator represents a NewOperator event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeNewOperator struct { - NewOperatorAddress common.Address - Admin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterNewOperator is a free log retrieval operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. -// -// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterNewOperator(opts *bind.FilterOpts, newOperatorAddress []common.Address, admin []common.Address) (*NegRiskCTFExchangeNewOperatorIterator, error) { - - var newOperatorAddressRule []interface{} - for _, newOperatorAddressItem := range newOperatorAddress { - newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeNewOperatorIterator{contract: _NegRiskCTFExchange.contract, event: "NewOperator", logs: logs, sub: sub}, nil -} - -// WatchNewOperator is a free log subscription operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. -// -// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchNewOperator(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeNewOperator, newOperatorAddress []common.Address, admin []common.Address) (event.Subscription, error) { - - var newOperatorAddressRule []interface{} - for _, newOperatorAddressItem := range newOperatorAddress { - newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeNewOperator) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseNewOperator is a log parse operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. -// -// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseNewOperator(log types.Log) (*NegRiskCTFExchangeNewOperator, error) { - event := new(NegRiskCTFExchangeNewOperator) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeOrderCancelledIterator is returned from FilterOrderCancelled and is used to iterate over the raw logs and unpacked data for OrderCancelled events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeOrderCancelledIterator struct { - Event *NegRiskCTFExchangeOrderCancelled // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeOrderCancelledIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeOrderCancelled) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeOrderCancelled) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeOrderCancelledIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeOrderCancelledIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeOrderCancelled represents a OrderCancelled event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeOrderCancelled struct { - OrderHash [32]byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOrderCancelled is a free log retrieval operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. -// -// Solidity: event OrderCancelled(bytes32 indexed orderHash) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterOrderCancelled(opts *bind.FilterOpts, orderHash [][32]byte) (*NegRiskCTFExchangeOrderCancelledIterator, error) { - - var orderHashRule []interface{} - for _, orderHashItem := range orderHash { - orderHashRule = append(orderHashRule, orderHashItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "OrderCancelled", orderHashRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeOrderCancelledIterator{contract: _NegRiskCTFExchange.contract, event: "OrderCancelled", logs: logs, sub: sub}, nil -} - -// WatchOrderCancelled is a free log subscription operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. -// -// Solidity: event OrderCancelled(bytes32 indexed orderHash) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchOrderCancelled(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeOrderCancelled, orderHash [][32]byte) (event.Subscription, error) { - - var orderHashRule []interface{} - for _, orderHashItem := range orderHash { - orderHashRule = append(orderHashRule, orderHashItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "OrderCancelled", orderHashRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeOrderCancelled) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOrderCancelled is a log parse operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. -// -// Solidity: event OrderCancelled(bytes32 indexed orderHash) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseOrderCancelled(log types.Log) (*NegRiskCTFExchangeOrderCancelled, error) { - event := new(NegRiskCTFExchangeOrderCancelled) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeOrderFilledIterator is returned from FilterOrderFilled and is used to iterate over the raw logs and unpacked data for OrderFilled events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeOrderFilledIterator struct { - Event *NegRiskCTFExchangeOrderFilled // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeOrderFilledIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeOrderFilled) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeOrderFilled) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeOrderFilledIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeOrderFilledIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeOrderFilled represents a OrderFilled event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeOrderFilled struct { - OrderHash [32]byte - Maker common.Address - Taker common.Address - MakerAssetId *big.Int - TakerAssetId *big.Int - MakerAmountFilled *big.Int - TakerAmountFilled *big.Int - Fee *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOrderFilled is a free log retrieval operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. -// -// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterOrderFilled(opts *bind.FilterOpts, orderHash [][32]byte, maker []common.Address, taker []common.Address) (*NegRiskCTFExchangeOrderFilledIterator, error) { - - var orderHashRule []interface{} - for _, orderHashItem := range orderHash { - orderHashRule = append(orderHashRule, orderHashItem) - } - var makerRule []interface{} - for _, makerItem := range maker { - makerRule = append(makerRule, makerItem) - } - var takerRule []interface{} - for _, takerItem := range taker { - takerRule = append(takerRule, takerItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeOrderFilledIterator{contract: _NegRiskCTFExchange.contract, event: "OrderFilled", logs: logs, sub: sub}, nil -} - -// WatchOrderFilled is a free log subscription operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. -// -// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchOrderFilled(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeOrderFilled, orderHash [][32]byte, maker []common.Address, taker []common.Address) (event.Subscription, error) { - - var orderHashRule []interface{} - for _, orderHashItem := range orderHash { - orderHashRule = append(orderHashRule, orderHashItem) - } - var makerRule []interface{} - for _, makerItem := range maker { - makerRule = append(makerRule, makerItem) - } - var takerRule []interface{} - for _, takerItem := range taker { - takerRule = append(takerRule, takerItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeOrderFilled) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOrderFilled is a log parse operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. -// -// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseOrderFilled(log types.Log) (*NegRiskCTFExchangeOrderFilled, error) { - event := new(NegRiskCTFExchangeOrderFilled) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeOrdersMatchedIterator is returned from FilterOrdersMatched and is used to iterate over the raw logs and unpacked data for OrdersMatched events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeOrdersMatchedIterator struct { - Event *NegRiskCTFExchangeOrdersMatched // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeOrdersMatchedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeOrdersMatched) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeOrdersMatched) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeOrdersMatchedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeOrdersMatchedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeOrdersMatched represents a OrdersMatched event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeOrdersMatched struct { - TakerOrderHash [32]byte - TakerOrderMaker common.Address - MakerAssetId *big.Int - TakerAssetId *big.Int - MakerAmountFilled *big.Int - TakerAmountFilled *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOrdersMatched is a free log retrieval operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. -// -// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterOrdersMatched(opts *bind.FilterOpts, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (*NegRiskCTFExchangeOrdersMatchedIterator, error) { - - var takerOrderHashRule []interface{} - for _, takerOrderHashItem := range takerOrderHash { - takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) - } - var takerOrderMakerRule []interface{} - for _, takerOrderMakerItem := range takerOrderMaker { - takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeOrdersMatchedIterator{contract: _NegRiskCTFExchange.contract, event: "OrdersMatched", logs: logs, sub: sub}, nil -} - -// WatchOrdersMatched is a free log subscription operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. -// -// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchOrdersMatched(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeOrdersMatched, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (event.Subscription, error) { - - var takerOrderHashRule []interface{} - for _, takerOrderHashItem := range takerOrderHash { - takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) - } - var takerOrderMakerRule []interface{} - for _, takerOrderMakerItem := range takerOrderMaker { - takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeOrdersMatched) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOrdersMatched is a log parse operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. -// -// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseOrdersMatched(log types.Log) (*NegRiskCTFExchangeOrdersMatched, error) { - event := new(NegRiskCTFExchangeOrdersMatched) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeProxyFactoryUpdatedIterator is returned from FilterProxyFactoryUpdated and is used to iterate over the raw logs and unpacked data for ProxyFactoryUpdated events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeProxyFactoryUpdatedIterator struct { - Event *NegRiskCTFExchangeProxyFactoryUpdated // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeProxyFactoryUpdatedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeProxyFactoryUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeProxyFactoryUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeProxyFactoryUpdatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeProxyFactoryUpdatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeProxyFactoryUpdated represents a ProxyFactoryUpdated event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeProxyFactoryUpdated struct { - OldProxyFactory common.Address - NewProxyFactory common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterProxyFactoryUpdated is a free log retrieval operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. -// -// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterProxyFactoryUpdated(opts *bind.FilterOpts, oldProxyFactory []common.Address, newProxyFactory []common.Address) (*NegRiskCTFExchangeProxyFactoryUpdatedIterator, error) { - - var oldProxyFactoryRule []interface{} - for _, oldProxyFactoryItem := range oldProxyFactory { - oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) - } - var newProxyFactoryRule []interface{} - for _, newProxyFactoryItem := range newProxyFactory { - newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeProxyFactoryUpdatedIterator{contract: _NegRiskCTFExchange.contract, event: "ProxyFactoryUpdated", logs: logs, sub: sub}, nil -} - -// WatchProxyFactoryUpdated is a free log subscription operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. -// -// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchProxyFactoryUpdated(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeProxyFactoryUpdated, oldProxyFactory []common.Address, newProxyFactory []common.Address) (event.Subscription, error) { - - var oldProxyFactoryRule []interface{} - for _, oldProxyFactoryItem := range oldProxyFactory { - oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) - } - var newProxyFactoryRule []interface{} - for _, newProxyFactoryItem := range newProxyFactory { - newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeProxyFactoryUpdated) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseProxyFactoryUpdated is a log parse operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. -// -// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseProxyFactoryUpdated(log types.Log) (*NegRiskCTFExchangeProxyFactoryUpdated, error) { - event := new(NegRiskCTFExchangeProxyFactoryUpdated) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeRemovedAdminIterator is returned from FilterRemovedAdmin and is used to iterate over the raw logs and unpacked data for RemovedAdmin events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeRemovedAdminIterator struct { - Event *NegRiskCTFExchangeRemovedAdmin // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeRemovedAdminIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeRemovedAdmin) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeRemovedAdmin) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeRemovedAdminIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeRemovedAdminIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeRemovedAdmin represents a RemovedAdmin event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeRemovedAdmin struct { - RemovedAdmin common.Address - Admin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterRemovedAdmin is a free log retrieval operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. -// -// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterRemovedAdmin(opts *bind.FilterOpts, removedAdmin []common.Address, admin []common.Address) (*NegRiskCTFExchangeRemovedAdminIterator, error) { - - var removedAdminRule []interface{} - for _, removedAdminItem := range removedAdmin { - removedAdminRule = append(removedAdminRule, removedAdminItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeRemovedAdminIterator{contract: _NegRiskCTFExchange.contract, event: "RemovedAdmin", logs: logs, sub: sub}, nil -} - -// WatchRemovedAdmin is a free log subscription operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. -// -// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchRemovedAdmin(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeRemovedAdmin, removedAdmin []common.Address, admin []common.Address) (event.Subscription, error) { - - var removedAdminRule []interface{} - for _, removedAdminItem := range removedAdmin { - removedAdminRule = append(removedAdminRule, removedAdminItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeRemovedAdmin) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseRemovedAdmin is a log parse operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. -// -// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseRemovedAdmin(log types.Log) (*NegRiskCTFExchangeRemovedAdmin, error) { - event := new(NegRiskCTFExchangeRemovedAdmin) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeRemovedOperatorIterator is returned from FilterRemovedOperator and is used to iterate over the raw logs and unpacked data for RemovedOperator events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeRemovedOperatorIterator struct { - Event *NegRiskCTFExchangeRemovedOperator // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeRemovedOperatorIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeRemovedOperator) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeRemovedOperator) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeRemovedOperatorIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeRemovedOperatorIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeRemovedOperator represents a RemovedOperator event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeRemovedOperator struct { - RemovedOperator common.Address - Admin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterRemovedOperator is a free log retrieval operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. -// -// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterRemovedOperator(opts *bind.FilterOpts, removedOperator []common.Address, admin []common.Address) (*NegRiskCTFExchangeRemovedOperatorIterator, error) { - - var removedOperatorRule []interface{} - for _, removedOperatorItem := range removedOperator { - removedOperatorRule = append(removedOperatorRule, removedOperatorItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeRemovedOperatorIterator{contract: _NegRiskCTFExchange.contract, event: "RemovedOperator", logs: logs, sub: sub}, nil -} - -// WatchRemovedOperator is a free log subscription operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. -// -// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchRemovedOperator(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeRemovedOperator, removedOperator []common.Address, admin []common.Address) (event.Subscription, error) { - - var removedOperatorRule []interface{} - for _, removedOperatorItem := range removedOperator { - removedOperatorRule = append(removedOperatorRule, removedOperatorItem) - } - var adminRule []interface{} - for _, adminItem := range admin { - adminRule = append(adminRule, adminItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeRemovedOperator) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseRemovedOperator is a log parse operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. -// -// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseRemovedOperator(log types.Log) (*NegRiskCTFExchangeRemovedOperator, error) { - event := new(NegRiskCTFExchangeRemovedOperator) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeSafeFactoryUpdatedIterator is returned from FilterSafeFactoryUpdated and is used to iterate over the raw logs and unpacked data for SafeFactoryUpdated events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeSafeFactoryUpdatedIterator struct { - Event *NegRiskCTFExchangeSafeFactoryUpdated // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeSafeFactoryUpdatedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeSafeFactoryUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeSafeFactoryUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeSafeFactoryUpdatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeSafeFactoryUpdatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeSafeFactoryUpdated represents a SafeFactoryUpdated event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeSafeFactoryUpdated struct { - OldSafeFactory common.Address - NewSafeFactory common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterSafeFactoryUpdated is a free log retrieval operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. -// -// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterSafeFactoryUpdated(opts *bind.FilterOpts, oldSafeFactory []common.Address, newSafeFactory []common.Address) (*NegRiskCTFExchangeSafeFactoryUpdatedIterator, error) { - - var oldSafeFactoryRule []interface{} - for _, oldSafeFactoryItem := range oldSafeFactory { - oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) - } - var newSafeFactoryRule []interface{} - for _, newSafeFactoryItem := range newSafeFactory { - newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeSafeFactoryUpdatedIterator{contract: _NegRiskCTFExchange.contract, event: "SafeFactoryUpdated", logs: logs, sub: sub}, nil -} - -// WatchSafeFactoryUpdated is a free log subscription operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. -// -// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchSafeFactoryUpdated(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeSafeFactoryUpdated, oldSafeFactory []common.Address, newSafeFactory []common.Address) (event.Subscription, error) { - - var oldSafeFactoryRule []interface{} - for _, oldSafeFactoryItem := range oldSafeFactory { - oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) - } - var newSafeFactoryRule []interface{} - for _, newSafeFactoryItem := range newSafeFactory { - newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeSafeFactoryUpdated) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseSafeFactoryUpdated is a log parse operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. -// -// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseSafeFactoryUpdated(log types.Log) (*NegRiskCTFExchangeSafeFactoryUpdated, error) { - event := new(NegRiskCTFExchangeSafeFactoryUpdated) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeTokenRegisteredIterator is returned from FilterTokenRegistered and is used to iterate over the raw logs and unpacked data for TokenRegistered events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeTokenRegisteredIterator struct { - Event *NegRiskCTFExchangeTokenRegistered // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeTokenRegisteredIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeTokenRegistered) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeTokenRegistered) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeTokenRegisteredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeTokenRegisteredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeTokenRegistered represents a TokenRegistered event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeTokenRegistered struct { - Token0 *big.Int - Token1 *big.Int - ConditionId [32]byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTokenRegistered is a free log retrieval operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. -// -// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterTokenRegistered(opts *bind.FilterOpts, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (*NegRiskCTFExchangeTokenRegisteredIterator, error) { - - var token0Rule []interface{} - for _, token0Item := range token0 { - token0Rule = append(token0Rule, token0Item) - } - var token1Rule []interface{} - for _, token1Item := range token1 { - token1Rule = append(token1Rule, token1Item) - } - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeTokenRegisteredIterator{contract: _NegRiskCTFExchange.contract, event: "TokenRegistered", logs: logs, sub: sub}, nil -} - -// WatchTokenRegistered is a free log subscription operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. -// -// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchTokenRegistered(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeTokenRegistered, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (event.Subscription, error) { - - var token0Rule []interface{} - for _, token0Item := range token0 { - token0Rule = append(token0Rule, token0Item) - } - var token1Rule []interface{} - for _, token1Item := range token1 { - token1Rule = append(token1Rule, token1Item) - } - var conditionIdRule []interface{} - for _, conditionIdItem := range conditionId { - conditionIdRule = append(conditionIdRule, conditionIdItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeTokenRegistered) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseTokenRegistered is a log parse operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. -// -// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseTokenRegistered(log types.Log) (*NegRiskCTFExchangeTokenRegistered, error) { - event := new(NegRiskCTFExchangeTokenRegistered) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeTradingPausedIterator is returned from FilterTradingPaused and is used to iterate over the raw logs and unpacked data for TradingPaused events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeTradingPausedIterator struct { - Event *NegRiskCTFExchangeTradingPaused // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeTradingPausedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeTradingPaused) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeTradingPaused) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeTradingPausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeTradingPausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeTradingPaused represents a TradingPaused event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeTradingPaused struct { - Pauser common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTradingPaused is a free log retrieval operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. -// -// Solidity: event TradingPaused(address indexed pauser) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterTradingPaused(opts *bind.FilterOpts, pauser []common.Address) (*NegRiskCTFExchangeTradingPausedIterator, error) { - - var pauserRule []interface{} - for _, pauserItem := range pauser { - pauserRule = append(pauserRule, pauserItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "TradingPaused", pauserRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeTradingPausedIterator{contract: _NegRiskCTFExchange.contract, event: "TradingPaused", logs: logs, sub: sub}, nil -} - -// WatchTradingPaused is a free log subscription operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. -// -// Solidity: event TradingPaused(address indexed pauser) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchTradingPaused(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeTradingPaused, pauser []common.Address) (event.Subscription, error) { - - var pauserRule []interface{} - for _, pauserItem := range pauser { - pauserRule = append(pauserRule, pauserItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "TradingPaused", pauserRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeTradingPaused) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseTradingPaused is a log parse operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. -// -// Solidity: event TradingPaused(address indexed pauser) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseTradingPaused(log types.Log) (*NegRiskCTFExchangeTradingPaused, error) { - event := new(NegRiskCTFExchangeTradingPaused) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// NegRiskCTFExchangeTradingUnpausedIterator is returned from FilterTradingUnpaused and is used to iterate over the raw logs and unpacked data for TradingUnpaused events raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeTradingUnpausedIterator struct { - Event *NegRiskCTFExchangeTradingUnpaused // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *NegRiskCTFExchangeTradingUnpausedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeTradingUnpaused) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(NegRiskCTFExchangeTradingUnpaused) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *NegRiskCTFExchangeTradingUnpausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *NegRiskCTFExchangeTradingUnpausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// NegRiskCTFExchangeTradingUnpaused represents a TradingUnpaused event raised by the NegRiskCTFExchange contract. -type NegRiskCTFExchangeTradingUnpaused struct { - Pauser common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTradingUnpaused is a free log retrieval operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. -// -// Solidity: event TradingUnpaused(address indexed pauser) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) FilterTradingUnpaused(opts *bind.FilterOpts, pauser []common.Address) (*NegRiskCTFExchangeTradingUnpausedIterator, error) { - - var pauserRule []interface{} - for _, pauserItem := range pauser { - pauserRule = append(pauserRule, pauserItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.FilterLogs(opts, "TradingUnpaused", pauserRule) - if err != nil { - return nil, err - } - return &NegRiskCTFExchangeTradingUnpausedIterator{contract: _NegRiskCTFExchange.contract, event: "TradingUnpaused", logs: logs, sub: sub}, nil -} - -// WatchTradingUnpaused is a free log subscription operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. -// -// Solidity: event TradingUnpaused(address indexed pauser) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) WatchTradingUnpaused(opts *bind.WatchOpts, sink chan<- *NegRiskCTFExchangeTradingUnpaused, pauser []common.Address) (event.Subscription, error) { - - var pauserRule []interface{} - for _, pauserItem := range pauser { - pauserRule = append(pauserRule, pauserItem) - } - - logs, sub, err := _NegRiskCTFExchange.contract.WatchLogs(opts, "TradingUnpaused", pauserRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(NegRiskCTFExchangeTradingUnpaused) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseTradingUnpaused is a log parse operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. -// -// Solidity: event TradingUnpaused(address indexed pauser) -func (_NegRiskCTFExchange *NegRiskCTFExchangeFilterer) ParseTradingUnpaused(log types.Log) (*NegRiskCTFExchangeTradingUnpaused, error) { - event := new(NegRiskCTFExchangeTradingUnpaused) - if err := _NegRiskCTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} From ff18d68225291d95849fc0dd21ae091f52913cbc Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 17:42:58 +0800 Subject: [PATCH 08/19] fix: add generated contract go files --- .../polymarket/contract_condition_tokens.go | 2112 +++++++++++++++++ 1 file changed, 2112 insertions(+) create mode 100644 provider/ethereum/contract/polymarket/contract_condition_tokens.go diff --git a/provider/ethereum/contract/polymarket/contract_condition_tokens.go b/provider/ethereum/contract/polymarket/contract_condition_tokens.go new file mode 100644 index 00000000..b391d33e --- /dev/null +++ b/provider/ethereum/contract/polymarket/contract_condition_tokens.go @@ -0,0 +1,2112 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polymarket + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ConditionTokensMetaData contains all meta data concerning the ConditionTokens contract. +var ConditionTokensMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"indexSets\",\"type\":\"uint256[]\"}],\"name\":\"redeemPositions\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\"},{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"payoutNumerators\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"ids\",\"type\":\"uint256[]\"},{\"name\":\"values\",\"type\":\"uint256[]\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeBatchTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"collectionId\",\"type\":\"bytes32\"}],\"name\":\"getPositionId\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owners\",\"type\":\"address[]\"},{\"name\":\"ids\",\"type\":\"uint256[]\"}],\"name\":\"balanceOfBatch\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"partition\",\"type\":\"uint256[]\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"splitPosition\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"oracle\",\"type\":\"address\"},{\"name\":\"questionId\",\"type\":\"bytes32\"},{\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"indexSet\",\"type\":\"uint256\"}],\"name\":\"getCollectionId\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"collateralToken\",\"type\":\"address\"},{\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"name\":\"partition\",\"type\":\"uint256[]\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mergePositions\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"questionId\",\"type\":\"bytes32\"},{\"name\":\"payouts\",\"type\":\"uint256[]\"}],\"name\":\"reportPayouts\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"getOutcomeSlotCount\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"oracle\",\"type\":\"address\"},{\"name\":\"questionId\",\"type\":\"bytes32\"},{\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"}],\"name\":\"prepareCondition\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"payoutDenominator\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"id\",\"type\":\"uint256\"},{\"name\":\"value\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"oracle\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"questionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"}],\"name\":\"ConditionPreparation\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"oracle\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"questionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"outcomeSlotCount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"payoutNumerators\",\"type\":\"uint256[]\"}],\"name\":\"ConditionResolution\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"stakeholder\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"collateralToken\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"partition\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"PositionSplit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"stakeholder\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"collateralToken\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"partition\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"PositionsMerge\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"redeemer\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"collateralToken\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"parentCollectionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"conditionId\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"indexSets\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"payout\",\"type\":\"uint256\"}],\"name\":\"PayoutRedemption\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"id\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"TransferSingle\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"ids\",\"type\":\"uint256[]\"},{\"indexed\":false,\"name\":\"values\",\"type\":\"uint256[]\"}],\"name\":\"TransferBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"value\",\"type\":\"string\"},{\"indexed\":true,\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"URI\",\"type\":\"event\"}]", +} + +// ConditionTokensABI is the input ABI used to generate the binding from. +// Deprecated: Use ConditionTokensMetaData.ABI instead. +var ConditionTokensABI = ConditionTokensMetaData.ABI + +// ConditionTokens is an auto generated Go binding around an Ethereum contract. +type ConditionTokens struct { + ConditionTokensCaller // Read-only binding to the contract + ConditionTokensTransactor // Write-only binding to the contract + ConditionTokensFilterer // Log filterer for contract events +} + +// ConditionTokensCaller is an auto generated read-only Go binding around an Ethereum contract. +type ConditionTokensCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConditionTokensTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ConditionTokensTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConditionTokensFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ConditionTokensFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConditionTokensSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ConditionTokensSession struct { + Contract *ConditionTokens // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ConditionTokensCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ConditionTokensCallerSession struct { + Contract *ConditionTokensCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ConditionTokensTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ConditionTokensTransactorSession struct { + Contract *ConditionTokensTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ConditionTokensRaw is an auto generated low-level Go binding around an Ethereum contract. +type ConditionTokensRaw struct { + Contract *ConditionTokens // Generic contract binding to access the raw methods on +} + +// ConditionTokensCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ConditionTokensCallerRaw struct { + Contract *ConditionTokensCaller // Generic read-only contract binding to access the raw methods on +} + +// ConditionTokensTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ConditionTokensTransactorRaw struct { + Contract *ConditionTokensTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewConditionTokens creates a new instance of ConditionTokens, bound to a specific deployed contract. +func NewConditionTokens(address common.Address, backend bind.ContractBackend) (*ConditionTokens, error) { + contract, err := bindConditionTokens(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ConditionTokens{ConditionTokensCaller: ConditionTokensCaller{contract: contract}, ConditionTokensTransactor: ConditionTokensTransactor{contract: contract}, ConditionTokensFilterer: ConditionTokensFilterer{contract: contract}}, nil +} + +// NewConditionTokensCaller creates a new read-only instance of ConditionTokens, bound to a specific deployed contract. +func NewConditionTokensCaller(address common.Address, caller bind.ContractCaller) (*ConditionTokensCaller, error) { + contract, err := bindConditionTokens(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ConditionTokensCaller{contract: contract}, nil +} + +// NewConditionTokensTransactor creates a new write-only instance of ConditionTokens, bound to a specific deployed contract. +func NewConditionTokensTransactor(address common.Address, transactor bind.ContractTransactor) (*ConditionTokensTransactor, error) { + contract, err := bindConditionTokens(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ConditionTokensTransactor{contract: contract}, nil +} + +// NewConditionTokensFilterer creates a new log filterer instance of ConditionTokens, bound to a specific deployed contract. +func NewConditionTokensFilterer(address common.Address, filterer bind.ContractFilterer) (*ConditionTokensFilterer, error) { + contract, err := bindConditionTokens(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ConditionTokensFilterer{contract: contract}, nil +} + +// bindConditionTokens binds a generic wrapper to an already deployed contract. +func bindConditionTokens(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ConditionTokensMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ConditionTokens *ConditionTokensRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ConditionTokens.Contract.ConditionTokensCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ConditionTokens *ConditionTokensRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ConditionTokens.Contract.ConditionTokensTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ConditionTokens *ConditionTokensRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ConditionTokens.Contract.ConditionTokensTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ConditionTokens *ConditionTokensCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ConditionTokens.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ConditionTokens *ConditionTokensTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ConditionTokens.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ConditionTokens *ConditionTokensTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ConditionTokens.Contract.contract.Transact(opts, method, params...) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e. +// +// Solidity: function balanceOf(address owner, uint256 id) view returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) BalanceOf(opts *bind.CallOpts, owner common.Address, id *big.Int) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "balanceOf", owner, id) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e. +// +// Solidity: function balanceOf(address owner, uint256 id) view returns(uint256) +func (_ConditionTokens *ConditionTokensSession) BalanceOf(owner common.Address, id *big.Int) (*big.Int, error) { + return _ConditionTokens.Contract.BalanceOf(&_ConditionTokens.CallOpts, owner, id) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e. +// +// Solidity: function balanceOf(address owner, uint256 id) view returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) BalanceOf(owner common.Address, id *big.Int) (*big.Int, error) { + return _ConditionTokens.Contract.BalanceOf(&_ConditionTokens.CallOpts, owner, id) +} + +// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4. +// +// Solidity: function balanceOfBatch(address[] owners, uint256[] ids) view returns(uint256[]) +func (_ConditionTokens *ConditionTokensCaller) BalanceOfBatch(opts *bind.CallOpts, owners []common.Address, ids []*big.Int) ([]*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "balanceOfBatch", owners, ids) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4. +// +// Solidity: function balanceOfBatch(address[] owners, uint256[] ids) view returns(uint256[]) +func (_ConditionTokens *ConditionTokensSession) BalanceOfBatch(owners []common.Address, ids []*big.Int) ([]*big.Int, error) { + return _ConditionTokens.Contract.BalanceOfBatch(&_ConditionTokens.CallOpts, owners, ids) +} + +// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4. +// +// Solidity: function balanceOfBatch(address[] owners, uint256[] ids) view returns(uint256[]) +func (_ConditionTokens *ConditionTokensCallerSession) BalanceOfBatch(owners []common.Address, ids []*big.Int) ([]*big.Int, error) { + return _ConditionTokens.Contract.BalanceOfBatch(&_ConditionTokens.CallOpts, owners, ids) +} + +// GetCollectionId is a free data retrieval call binding the contract method 0x856296f7. +// +// Solidity: function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) view returns(bytes32) +func (_ConditionTokens *ConditionTokensCaller) GetCollectionId(opts *bind.CallOpts, parentCollectionId [32]byte, conditionId [32]byte, indexSet *big.Int) ([32]byte, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "getCollectionId", parentCollectionId, conditionId, indexSet) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetCollectionId is a free data retrieval call binding the contract method 0x856296f7. +// +// Solidity: function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) view returns(bytes32) +func (_ConditionTokens *ConditionTokensSession) GetCollectionId(parentCollectionId [32]byte, conditionId [32]byte, indexSet *big.Int) ([32]byte, error) { + return _ConditionTokens.Contract.GetCollectionId(&_ConditionTokens.CallOpts, parentCollectionId, conditionId, indexSet) +} + +// GetCollectionId is a free data retrieval call binding the contract method 0x856296f7. +// +// Solidity: function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) view returns(bytes32) +func (_ConditionTokens *ConditionTokensCallerSession) GetCollectionId(parentCollectionId [32]byte, conditionId [32]byte, indexSet *big.Int) ([32]byte, error) { + return _ConditionTokens.Contract.GetCollectionId(&_ConditionTokens.CallOpts, parentCollectionId, conditionId, indexSet) +} + +// GetConditionId is a free data retrieval call binding the contract method 0x852c6ae2. +// +// Solidity: function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) pure returns(bytes32) +func (_ConditionTokens *ConditionTokensCaller) GetConditionId(opts *bind.CallOpts, oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) ([32]byte, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "getConditionId", oracle, questionId, outcomeSlotCount) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetConditionId is a free data retrieval call binding the contract method 0x852c6ae2. +// +// Solidity: function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) pure returns(bytes32) +func (_ConditionTokens *ConditionTokensSession) GetConditionId(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) ([32]byte, error) { + return _ConditionTokens.Contract.GetConditionId(&_ConditionTokens.CallOpts, oracle, questionId, outcomeSlotCount) +} + +// GetConditionId is a free data retrieval call binding the contract method 0x852c6ae2. +// +// Solidity: function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount) pure returns(bytes32) +func (_ConditionTokens *ConditionTokensCallerSession) GetConditionId(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) ([32]byte, error) { + return _ConditionTokens.Contract.GetConditionId(&_ConditionTokens.CallOpts, oracle, questionId, outcomeSlotCount) +} + +// GetOutcomeSlotCount is a free data retrieval call binding the contract method 0xd42dc0c2. +// +// Solidity: function getOutcomeSlotCount(bytes32 conditionId) view returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) GetOutcomeSlotCount(opts *bind.CallOpts, conditionId [32]byte) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "getOutcomeSlotCount", conditionId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetOutcomeSlotCount is a free data retrieval call binding the contract method 0xd42dc0c2. +// +// Solidity: function getOutcomeSlotCount(bytes32 conditionId) view returns(uint256) +func (_ConditionTokens *ConditionTokensSession) GetOutcomeSlotCount(conditionId [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.GetOutcomeSlotCount(&_ConditionTokens.CallOpts, conditionId) +} + +// GetOutcomeSlotCount is a free data retrieval call binding the contract method 0xd42dc0c2. +// +// Solidity: function getOutcomeSlotCount(bytes32 conditionId) view returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) GetOutcomeSlotCount(conditionId [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.GetOutcomeSlotCount(&_ConditionTokens.CallOpts, conditionId) +} + +// GetPositionId is a free data retrieval call binding the contract method 0x39dd7530. +// +// Solidity: function getPositionId(address collateralToken, bytes32 collectionId) pure returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) GetPositionId(opts *bind.CallOpts, collateralToken common.Address, collectionId [32]byte) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "getPositionId", collateralToken, collectionId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetPositionId is a free data retrieval call binding the contract method 0x39dd7530. +// +// Solidity: function getPositionId(address collateralToken, bytes32 collectionId) pure returns(uint256) +func (_ConditionTokens *ConditionTokensSession) GetPositionId(collateralToken common.Address, collectionId [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.GetPositionId(&_ConditionTokens.CallOpts, collateralToken, collectionId) +} + +// GetPositionId is a free data retrieval call binding the contract method 0x39dd7530. +// +// Solidity: function getPositionId(address collateralToken, bytes32 collectionId) pure returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) GetPositionId(collateralToken common.Address, collectionId [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.GetPositionId(&_ConditionTokens.CallOpts, collateralToken, collectionId) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) +func (_ConditionTokens *ConditionTokensCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "isApprovedForAll", owner, operator) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) +func (_ConditionTokens *ConditionTokensSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) { + return _ConditionTokens.Contract.IsApprovedForAll(&_ConditionTokens.CallOpts, owner, operator) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) +func (_ConditionTokens *ConditionTokensCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) { + return _ConditionTokens.Contract.IsApprovedForAll(&_ConditionTokens.CallOpts, owner, operator) +} + +// PayoutDenominator is a free data retrieval call binding the contract method 0xdd34de67. +// +// Solidity: function payoutDenominator(bytes32 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) PayoutDenominator(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "payoutDenominator", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PayoutDenominator is a free data retrieval call binding the contract method 0xdd34de67. +// +// Solidity: function payoutDenominator(bytes32 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensSession) PayoutDenominator(arg0 [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.PayoutDenominator(&_ConditionTokens.CallOpts, arg0) +} + +// PayoutDenominator is a free data retrieval call binding the contract method 0xdd34de67. +// +// Solidity: function payoutDenominator(bytes32 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) PayoutDenominator(arg0 [32]byte) (*big.Int, error) { + return _ConditionTokens.Contract.PayoutDenominator(&_ConditionTokens.CallOpts, arg0) +} + +// PayoutNumerators is a free data retrieval call binding the contract method 0x0504c814. +// +// Solidity: function payoutNumerators(bytes32 , uint256 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensCaller) PayoutNumerators(opts *bind.CallOpts, arg0 [32]byte, arg1 *big.Int) (*big.Int, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "payoutNumerators", arg0, arg1) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PayoutNumerators is a free data retrieval call binding the contract method 0x0504c814. +// +// Solidity: function payoutNumerators(bytes32 , uint256 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensSession) PayoutNumerators(arg0 [32]byte, arg1 *big.Int) (*big.Int, error) { + return _ConditionTokens.Contract.PayoutNumerators(&_ConditionTokens.CallOpts, arg0, arg1) +} + +// PayoutNumerators is a free data retrieval call binding the contract method 0x0504c814. +// +// Solidity: function payoutNumerators(bytes32 , uint256 ) view returns(uint256) +func (_ConditionTokens *ConditionTokensCallerSession) PayoutNumerators(arg0 [32]byte, arg1 *big.Int) (*big.Int, error) { + return _ConditionTokens.Contract.PayoutNumerators(&_ConditionTokens.CallOpts, arg0, arg1) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_ConditionTokens *ConditionTokensCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { + var out []interface{} + err := _ConditionTokens.contract.Call(opts, &out, "supportsInterface", interfaceId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_ConditionTokens *ConditionTokensSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _ConditionTokens.Contract.SupportsInterface(&_ConditionTokens.CallOpts, interfaceId) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_ConditionTokens *ConditionTokensCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _ConditionTokens.Contract.SupportsInterface(&_ConditionTokens.CallOpts, interfaceId) +} + +// MergePositions is a paid mutator transaction binding the contract method 0x9e7212ad. +// +// Solidity: function mergePositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensTransactor) MergePositions(opts *bind.TransactOpts, collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "mergePositions", collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// MergePositions is a paid mutator transaction binding the contract method 0x9e7212ad. +// +// Solidity: function mergePositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensSession) MergePositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.MergePositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// MergePositions is a paid mutator transaction binding the contract method 0x9e7212ad. +// +// Solidity: function mergePositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) MergePositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.MergePositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// PrepareCondition is a paid mutator transaction binding the contract method 0xd96ee754. +// +// Solidity: function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) returns() +func (_ConditionTokens *ConditionTokensTransactor) PrepareCondition(opts *bind.TransactOpts, oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "prepareCondition", oracle, questionId, outcomeSlotCount) +} + +// PrepareCondition is a paid mutator transaction binding the contract method 0xd96ee754. +// +// Solidity: function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) returns() +func (_ConditionTokens *ConditionTokensSession) PrepareCondition(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.PrepareCondition(&_ConditionTokens.TransactOpts, oracle, questionId, outcomeSlotCount) +} + +// PrepareCondition is a paid mutator transaction binding the contract method 0xd96ee754. +// +// Solidity: function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) PrepareCondition(oracle common.Address, questionId [32]byte, outcomeSlotCount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.PrepareCondition(&_ConditionTokens.TransactOpts, oracle, questionId, outcomeSlotCount) +} + +// RedeemPositions is a paid mutator transaction binding the contract method 0x01b7037c. +// +// Solidity: function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) returns() +func (_ConditionTokens *ConditionTokensTransactor) RedeemPositions(opts *bind.TransactOpts, collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, indexSets []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "redeemPositions", collateralToken, parentCollectionId, conditionId, indexSets) +} + +// RedeemPositions is a paid mutator transaction binding the contract method 0x01b7037c. +// +// Solidity: function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) returns() +func (_ConditionTokens *ConditionTokensSession) RedeemPositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, indexSets []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.RedeemPositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, indexSets) +} + +// RedeemPositions is a paid mutator transaction binding the contract method 0x01b7037c. +// +// Solidity: function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) RedeemPositions(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, indexSets []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.RedeemPositions(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, indexSets) +} + +// ReportPayouts is a paid mutator transaction binding the contract method 0xc49298ac. +// +// Solidity: function reportPayouts(bytes32 questionId, uint256[] payouts) returns() +func (_ConditionTokens *ConditionTokensTransactor) ReportPayouts(opts *bind.TransactOpts, questionId [32]byte, payouts []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "reportPayouts", questionId, payouts) +} + +// ReportPayouts is a paid mutator transaction binding the contract method 0xc49298ac. +// +// Solidity: function reportPayouts(bytes32 questionId, uint256[] payouts) returns() +func (_ConditionTokens *ConditionTokensSession) ReportPayouts(questionId [32]byte, payouts []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.ReportPayouts(&_ConditionTokens.TransactOpts, questionId, payouts) +} + +// ReportPayouts is a paid mutator transaction binding the contract method 0xc49298ac. +// +// Solidity: function reportPayouts(bytes32 questionId, uint256[] payouts) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) ReportPayouts(questionId [32]byte, payouts []*big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.ReportPayouts(&_ConditionTokens.TransactOpts, questionId, payouts) +} + +// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6. +// +// Solidity: function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] values, bytes data) returns() +func (_ConditionTokens *ConditionTokensTransactor) SafeBatchTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ids []*big.Int, values []*big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "safeBatchTransferFrom", from, to, ids, values, data) +} + +// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6. +// +// Solidity: function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] values, bytes data) returns() +func (_ConditionTokens *ConditionTokensSession) SafeBatchTransferFrom(from common.Address, to common.Address, ids []*big.Int, values []*big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.Contract.SafeBatchTransferFrom(&_ConditionTokens.TransactOpts, from, to, ids, values, data) +} + +// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6. +// +// Solidity: function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] values, bytes data) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) SafeBatchTransferFrom(from common.Address, to common.Address, ids []*big.Int, values []*big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.Contract.SafeBatchTransferFrom(&_ConditionTokens.TransactOpts, from, to, ids, values, data) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes data) returns() +func (_ConditionTokens *ConditionTokensTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, id *big.Int, value *big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "safeTransferFrom", from, to, id, value, data) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes data) returns() +func (_ConditionTokens *ConditionTokensSession) SafeTransferFrom(from common.Address, to common.Address, id *big.Int, value *big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.Contract.SafeTransferFrom(&_ConditionTokens.TransactOpts, from, to, id, value, data) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes data) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) SafeTransferFrom(from common.Address, to common.Address, id *big.Int, value *big.Int, data []byte) (*types.Transaction, error) { + return _ConditionTokens.Contract.SafeTransferFrom(&_ConditionTokens.TransactOpts, from, to, id, value, data) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address operator, bool approved) returns() +func (_ConditionTokens *ConditionTokensTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, approved bool) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "setApprovalForAll", operator, approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address operator, bool approved) returns() +func (_ConditionTokens *ConditionTokensSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) { + return _ConditionTokens.Contract.SetApprovalForAll(&_ConditionTokens.TransactOpts, operator, approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address operator, bool approved) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) { + return _ConditionTokens.Contract.SetApprovalForAll(&_ConditionTokens.TransactOpts, operator, approved) +} + +// SplitPosition is a paid mutator transaction binding the contract method 0x72ce4275. +// +// Solidity: function splitPosition(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensTransactor) SplitPosition(opts *bind.TransactOpts, collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.contract.Transact(opts, "splitPosition", collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// SplitPosition is a paid mutator transaction binding the contract method 0x72ce4275. +// +// Solidity: function splitPosition(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensSession) SplitPosition(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.SplitPosition(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// SplitPosition is a paid mutator transaction binding the contract method 0x72ce4275. +// +// Solidity: function splitPosition(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] partition, uint256 amount) returns() +func (_ConditionTokens *ConditionTokensTransactorSession) SplitPosition(collateralToken common.Address, parentCollectionId [32]byte, conditionId [32]byte, partition []*big.Int, amount *big.Int) (*types.Transaction, error) { + return _ConditionTokens.Contract.SplitPosition(&_ConditionTokens.TransactOpts, collateralToken, parentCollectionId, conditionId, partition, amount) +} + +// ConditionTokensApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ConditionTokens contract. +type ConditionTokensApprovalForAllIterator struct { + Event *ConditionTokensApprovalForAll // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensApprovalForAllIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensApprovalForAllIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensApprovalForAllIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensApprovalForAll represents a ApprovalForAll event raised by the ConditionTokens contract. +type ConditionTokensApprovalForAll struct { + Owner common.Address + Operator common.Address + Approved bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved) +func (_ConditionTokens *ConditionTokensFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ConditionTokensApprovalForAllIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule) + if err != nil { + return nil, err + } + return &ConditionTokensApprovalForAllIterator{contract: _ConditionTokens.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil +} + +// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved) +func (_ConditionTokens *ConditionTokensFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ConditionTokensApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensApprovalForAll) + if err := _ConditionTokens.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved) +func (_ConditionTokens *ConditionTokensFilterer) ParseApprovalForAll(log types.Log) (*ConditionTokensApprovalForAll, error) { + event := new(ConditionTokensApprovalForAll) + if err := _ConditionTokens.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensConditionPreparationIterator is returned from FilterConditionPreparation and is used to iterate over the raw logs and unpacked data for ConditionPreparation events raised by the ConditionTokens contract. +type ConditionTokensConditionPreparationIterator struct { + Event *ConditionTokensConditionPreparation // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensConditionPreparationIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensConditionPreparation) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensConditionPreparation) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensConditionPreparationIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensConditionPreparationIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensConditionPreparation represents a ConditionPreparation event raised by the ConditionTokens contract. +type ConditionTokensConditionPreparation struct { + ConditionId [32]byte + Oracle common.Address + QuestionId [32]byte + OutcomeSlotCount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterConditionPreparation is a free log retrieval operation binding the contract event 0xab3760c3bd2bb38b5bcf54dc79802ed67338b4cf29f3054ded67ed24661e4177. +// +// Solidity: event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount) +func (_ConditionTokens *ConditionTokensFilterer) FilterConditionPreparation(opts *bind.FilterOpts, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (*ConditionTokensConditionPreparationIterator, error) { + + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + var oracleRule []interface{} + for _, oracleItem := range oracle { + oracleRule = append(oracleRule, oracleItem) + } + var questionIdRule []interface{} + for _, questionIdItem := range questionId { + questionIdRule = append(questionIdRule, questionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "ConditionPreparation", conditionIdRule, oracleRule, questionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensConditionPreparationIterator{contract: _ConditionTokens.contract, event: "ConditionPreparation", logs: logs, sub: sub}, nil +} + +// WatchConditionPreparation is a free log subscription operation binding the contract event 0xab3760c3bd2bb38b5bcf54dc79802ed67338b4cf29f3054ded67ed24661e4177. +// +// Solidity: event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount) +func (_ConditionTokens *ConditionTokensFilterer) WatchConditionPreparation(opts *bind.WatchOpts, sink chan<- *ConditionTokensConditionPreparation, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (event.Subscription, error) { + + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + var oracleRule []interface{} + for _, oracleItem := range oracle { + oracleRule = append(oracleRule, oracleItem) + } + var questionIdRule []interface{} + for _, questionIdItem := range questionId { + questionIdRule = append(questionIdRule, questionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "ConditionPreparation", conditionIdRule, oracleRule, questionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensConditionPreparation) + if err := _ConditionTokens.contract.UnpackLog(event, "ConditionPreparation", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseConditionPreparation is a log parse operation binding the contract event 0xab3760c3bd2bb38b5bcf54dc79802ed67338b4cf29f3054ded67ed24661e4177. +// +// Solidity: event ConditionPreparation(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount) +func (_ConditionTokens *ConditionTokensFilterer) ParseConditionPreparation(log types.Log) (*ConditionTokensConditionPreparation, error) { + event := new(ConditionTokensConditionPreparation) + if err := _ConditionTokens.contract.UnpackLog(event, "ConditionPreparation", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensConditionResolutionIterator is returned from FilterConditionResolution and is used to iterate over the raw logs and unpacked data for ConditionResolution events raised by the ConditionTokens contract. +type ConditionTokensConditionResolutionIterator struct { + Event *ConditionTokensConditionResolution // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensConditionResolutionIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensConditionResolution) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensConditionResolution) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensConditionResolutionIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensConditionResolutionIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensConditionResolution represents a ConditionResolution event raised by the ConditionTokens contract. +type ConditionTokensConditionResolution struct { + ConditionId [32]byte + Oracle common.Address + QuestionId [32]byte + OutcomeSlotCount *big.Int + PayoutNumerators []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterConditionResolution is a free log retrieval operation binding the contract event 0xb44d84d3289691f71497564b85d4233648d9dbae8cbdbb4329f301c3a0185894. +// +// Solidity: event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators) +func (_ConditionTokens *ConditionTokensFilterer) FilterConditionResolution(opts *bind.FilterOpts, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (*ConditionTokensConditionResolutionIterator, error) { + + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + var oracleRule []interface{} + for _, oracleItem := range oracle { + oracleRule = append(oracleRule, oracleItem) + } + var questionIdRule []interface{} + for _, questionIdItem := range questionId { + questionIdRule = append(questionIdRule, questionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "ConditionResolution", conditionIdRule, oracleRule, questionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensConditionResolutionIterator{contract: _ConditionTokens.contract, event: "ConditionResolution", logs: logs, sub: sub}, nil +} + +// WatchConditionResolution is a free log subscription operation binding the contract event 0xb44d84d3289691f71497564b85d4233648d9dbae8cbdbb4329f301c3a0185894. +// +// Solidity: event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators) +func (_ConditionTokens *ConditionTokensFilterer) WatchConditionResolution(opts *bind.WatchOpts, sink chan<- *ConditionTokensConditionResolution, conditionId [][32]byte, oracle []common.Address, questionId [][32]byte) (event.Subscription, error) { + + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + var oracleRule []interface{} + for _, oracleItem := range oracle { + oracleRule = append(oracleRule, oracleItem) + } + var questionIdRule []interface{} + for _, questionIdItem := range questionId { + questionIdRule = append(questionIdRule, questionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "ConditionResolution", conditionIdRule, oracleRule, questionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensConditionResolution) + if err := _ConditionTokens.contract.UnpackLog(event, "ConditionResolution", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseConditionResolution is a log parse operation binding the contract event 0xb44d84d3289691f71497564b85d4233648d9dbae8cbdbb4329f301c3a0185894. +// +// Solidity: event ConditionResolution(bytes32 indexed conditionId, address indexed oracle, bytes32 indexed questionId, uint256 outcomeSlotCount, uint256[] payoutNumerators) +func (_ConditionTokens *ConditionTokensFilterer) ParseConditionResolution(log types.Log) (*ConditionTokensConditionResolution, error) { + event := new(ConditionTokensConditionResolution) + if err := _ConditionTokens.contract.UnpackLog(event, "ConditionResolution", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensPayoutRedemptionIterator is returned from FilterPayoutRedemption and is used to iterate over the raw logs and unpacked data for PayoutRedemption events raised by the ConditionTokens contract. +type ConditionTokensPayoutRedemptionIterator struct { + Event *ConditionTokensPayoutRedemption // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensPayoutRedemptionIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPayoutRedemption) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPayoutRedemption) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensPayoutRedemptionIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensPayoutRedemptionIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensPayoutRedemption represents a PayoutRedemption event raised by the ConditionTokens contract. +type ConditionTokensPayoutRedemption struct { + Redeemer common.Address + CollateralToken common.Address + ParentCollectionId [32]byte + ConditionId [32]byte + IndexSets []*big.Int + Payout *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPayoutRedemption is a free log retrieval operation binding the contract event 0x2682012a4a4f1973119f1c9b90745d1bd91fa2bab387344f044cb3586864d18d. +// +// Solidity: event PayoutRedemption(address indexed redeemer, address indexed collateralToken, bytes32 indexed parentCollectionId, bytes32 conditionId, uint256[] indexSets, uint256 payout) +func (_ConditionTokens *ConditionTokensFilterer) FilterPayoutRedemption(opts *bind.FilterOpts, redeemer []common.Address, collateralToken []common.Address, parentCollectionId [][32]byte) (*ConditionTokensPayoutRedemptionIterator, error) { + + var redeemerRule []interface{} + for _, redeemerItem := range redeemer { + redeemerRule = append(redeemerRule, redeemerItem) + } + var collateralTokenRule []interface{} + for _, collateralTokenItem := range collateralToken { + collateralTokenRule = append(collateralTokenRule, collateralTokenItem) + } + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "PayoutRedemption", redeemerRule, collateralTokenRule, parentCollectionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensPayoutRedemptionIterator{contract: _ConditionTokens.contract, event: "PayoutRedemption", logs: logs, sub: sub}, nil +} + +// WatchPayoutRedemption is a free log subscription operation binding the contract event 0x2682012a4a4f1973119f1c9b90745d1bd91fa2bab387344f044cb3586864d18d. +// +// Solidity: event PayoutRedemption(address indexed redeemer, address indexed collateralToken, bytes32 indexed parentCollectionId, bytes32 conditionId, uint256[] indexSets, uint256 payout) +func (_ConditionTokens *ConditionTokensFilterer) WatchPayoutRedemption(opts *bind.WatchOpts, sink chan<- *ConditionTokensPayoutRedemption, redeemer []common.Address, collateralToken []common.Address, parentCollectionId [][32]byte) (event.Subscription, error) { + + var redeemerRule []interface{} + for _, redeemerItem := range redeemer { + redeemerRule = append(redeemerRule, redeemerItem) + } + var collateralTokenRule []interface{} + for _, collateralTokenItem := range collateralToken { + collateralTokenRule = append(collateralTokenRule, collateralTokenItem) + } + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "PayoutRedemption", redeemerRule, collateralTokenRule, parentCollectionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensPayoutRedemption) + if err := _ConditionTokens.contract.UnpackLog(event, "PayoutRedemption", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePayoutRedemption is a log parse operation binding the contract event 0x2682012a4a4f1973119f1c9b90745d1bd91fa2bab387344f044cb3586864d18d. +// +// Solidity: event PayoutRedemption(address indexed redeemer, address indexed collateralToken, bytes32 indexed parentCollectionId, bytes32 conditionId, uint256[] indexSets, uint256 payout) +func (_ConditionTokens *ConditionTokensFilterer) ParsePayoutRedemption(log types.Log) (*ConditionTokensPayoutRedemption, error) { + event := new(ConditionTokensPayoutRedemption) + if err := _ConditionTokens.contract.UnpackLog(event, "PayoutRedemption", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensPositionSplitIterator is returned from FilterPositionSplit and is used to iterate over the raw logs and unpacked data for PositionSplit events raised by the ConditionTokens contract. +type ConditionTokensPositionSplitIterator struct { + Event *ConditionTokensPositionSplit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensPositionSplitIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPositionSplit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPositionSplit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensPositionSplitIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensPositionSplitIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensPositionSplit represents a PositionSplit event raised by the ConditionTokens contract. +type ConditionTokensPositionSplit struct { + Stakeholder common.Address + CollateralToken common.Address + ParentCollectionId [32]byte + ConditionId [32]byte + Partition []*big.Int + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPositionSplit is a free log retrieval operation binding the contract event 0x2e6bb91f8cbcda0c93623c54d0403a43514fabc40084ec96b6d5379a74786298. +// +// Solidity: event PositionSplit(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) FilterPositionSplit(opts *bind.FilterOpts, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (*ConditionTokensPositionSplitIterator, error) { + + var stakeholderRule []interface{} + for _, stakeholderItem := range stakeholder { + stakeholderRule = append(stakeholderRule, stakeholderItem) + } + + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "PositionSplit", stakeholderRule, parentCollectionIdRule, conditionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensPositionSplitIterator{contract: _ConditionTokens.contract, event: "PositionSplit", logs: logs, sub: sub}, nil +} + +// WatchPositionSplit is a free log subscription operation binding the contract event 0x2e6bb91f8cbcda0c93623c54d0403a43514fabc40084ec96b6d5379a74786298. +// +// Solidity: event PositionSplit(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) WatchPositionSplit(opts *bind.WatchOpts, sink chan<- *ConditionTokensPositionSplit, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (event.Subscription, error) { + + var stakeholderRule []interface{} + for _, stakeholderItem := range stakeholder { + stakeholderRule = append(stakeholderRule, stakeholderItem) + } + + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "PositionSplit", stakeholderRule, parentCollectionIdRule, conditionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensPositionSplit) + if err := _ConditionTokens.contract.UnpackLog(event, "PositionSplit", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePositionSplit is a log parse operation binding the contract event 0x2e6bb91f8cbcda0c93623c54d0403a43514fabc40084ec96b6d5379a74786298. +// +// Solidity: event PositionSplit(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) ParsePositionSplit(log types.Log) (*ConditionTokensPositionSplit, error) { + event := new(ConditionTokensPositionSplit) + if err := _ConditionTokens.contract.UnpackLog(event, "PositionSplit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensPositionsMergeIterator is returned from FilterPositionsMerge and is used to iterate over the raw logs and unpacked data for PositionsMerge events raised by the ConditionTokens contract. +type ConditionTokensPositionsMergeIterator struct { + Event *ConditionTokensPositionsMerge // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensPositionsMergeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPositionsMerge) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensPositionsMerge) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensPositionsMergeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensPositionsMergeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensPositionsMerge represents a PositionsMerge event raised by the ConditionTokens contract. +type ConditionTokensPositionsMerge struct { + Stakeholder common.Address + CollateralToken common.Address + ParentCollectionId [32]byte + ConditionId [32]byte + Partition []*big.Int + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPositionsMerge is a free log retrieval operation binding the contract event 0x6f13ca62553fcc2bcd2372180a43949c1e4cebba603901ede2f4e14f36b282ca. +// +// Solidity: event PositionsMerge(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) FilterPositionsMerge(opts *bind.FilterOpts, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (*ConditionTokensPositionsMergeIterator, error) { + + var stakeholderRule []interface{} + for _, stakeholderItem := range stakeholder { + stakeholderRule = append(stakeholderRule, stakeholderItem) + } + + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "PositionsMerge", stakeholderRule, parentCollectionIdRule, conditionIdRule) + if err != nil { + return nil, err + } + return &ConditionTokensPositionsMergeIterator{contract: _ConditionTokens.contract, event: "PositionsMerge", logs: logs, sub: sub}, nil +} + +// WatchPositionsMerge is a free log subscription operation binding the contract event 0x6f13ca62553fcc2bcd2372180a43949c1e4cebba603901ede2f4e14f36b282ca. +// +// Solidity: event PositionsMerge(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) WatchPositionsMerge(opts *bind.WatchOpts, sink chan<- *ConditionTokensPositionsMerge, stakeholder []common.Address, parentCollectionId [][32]byte, conditionId [][32]byte) (event.Subscription, error) { + + var stakeholderRule []interface{} + for _, stakeholderItem := range stakeholder { + stakeholderRule = append(stakeholderRule, stakeholderItem) + } + + var parentCollectionIdRule []interface{} + for _, parentCollectionIdItem := range parentCollectionId { + parentCollectionIdRule = append(parentCollectionIdRule, parentCollectionIdItem) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "PositionsMerge", stakeholderRule, parentCollectionIdRule, conditionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensPositionsMerge) + if err := _ConditionTokens.contract.UnpackLog(event, "PositionsMerge", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePositionsMerge is a log parse operation binding the contract event 0x6f13ca62553fcc2bcd2372180a43949c1e4cebba603901ede2f4e14f36b282ca. +// +// Solidity: event PositionsMerge(address indexed stakeholder, address collateralToken, bytes32 indexed parentCollectionId, bytes32 indexed conditionId, uint256[] partition, uint256 amount) +func (_ConditionTokens *ConditionTokensFilterer) ParsePositionsMerge(log types.Log) (*ConditionTokensPositionsMerge, error) { + event := new(ConditionTokensPositionsMerge) + if err := _ConditionTokens.contract.UnpackLog(event, "PositionsMerge", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensTransferBatchIterator is returned from FilterTransferBatch and is used to iterate over the raw logs and unpacked data for TransferBatch events raised by the ConditionTokens contract. +type ConditionTokensTransferBatchIterator struct { + Event *ConditionTokensTransferBatch // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensTransferBatchIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensTransferBatch) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensTransferBatch) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensTransferBatchIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensTransferBatchIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensTransferBatch represents a TransferBatch event raised by the ConditionTokens contract. +type ConditionTokensTransferBatch struct { + Operator common.Address + From common.Address + To common.Address + Ids []*big.Int + Values []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransferBatch is a free log retrieval operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb. +// +// Solidity: event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values) +func (_ConditionTokens *ConditionTokensFilterer) FilterTransferBatch(opts *bind.FilterOpts, operator []common.Address, from []common.Address, to []common.Address) (*ConditionTokensTransferBatchIterator, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "TransferBatch", operatorRule, fromRule, toRule) + if err != nil { + return nil, err + } + return &ConditionTokensTransferBatchIterator{contract: _ConditionTokens.contract, event: "TransferBatch", logs: logs, sub: sub}, nil +} + +// WatchTransferBatch is a free log subscription operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb. +// +// Solidity: event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values) +func (_ConditionTokens *ConditionTokensFilterer) WatchTransferBatch(opts *bind.WatchOpts, sink chan<- *ConditionTokensTransferBatch, operator []common.Address, from []common.Address, to []common.Address) (event.Subscription, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "TransferBatch", operatorRule, fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensTransferBatch) + if err := _ConditionTokens.contract.UnpackLog(event, "TransferBatch", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransferBatch is a log parse operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb. +// +// Solidity: event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values) +func (_ConditionTokens *ConditionTokensFilterer) ParseTransferBatch(log types.Log) (*ConditionTokensTransferBatch, error) { + event := new(ConditionTokensTransferBatch) + if err := _ConditionTokens.contract.UnpackLog(event, "TransferBatch", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensTransferSingleIterator is returned from FilterTransferSingle and is used to iterate over the raw logs and unpacked data for TransferSingle events raised by the ConditionTokens contract. +type ConditionTokensTransferSingleIterator struct { + Event *ConditionTokensTransferSingle // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensTransferSingleIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensTransferSingle) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensTransferSingle) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensTransferSingleIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensTransferSingleIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensTransferSingle represents a TransferSingle event raised by the ConditionTokens contract. +type ConditionTokensTransferSingle struct { + Operator common.Address + From common.Address + To common.Address + Id *big.Int + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransferSingle is a free log retrieval operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62. +// +// Solidity: event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value) +func (_ConditionTokens *ConditionTokensFilterer) FilterTransferSingle(opts *bind.FilterOpts, operator []common.Address, from []common.Address, to []common.Address) (*ConditionTokensTransferSingleIterator, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "TransferSingle", operatorRule, fromRule, toRule) + if err != nil { + return nil, err + } + return &ConditionTokensTransferSingleIterator{contract: _ConditionTokens.contract, event: "TransferSingle", logs: logs, sub: sub}, nil +} + +// WatchTransferSingle is a free log subscription operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62. +// +// Solidity: event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value) +func (_ConditionTokens *ConditionTokensFilterer) WatchTransferSingle(opts *bind.WatchOpts, sink chan<- *ConditionTokensTransferSingle, operator []common.Address, from []common.Address, to []common.Address) (event.Subscription, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "TransferSingle", operatorRule, fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensTransferSingle) + if err := _ConditionTokens.contract.UnpackLog(event, "TransferSingle", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransferSingle is a log parse operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62. +// +// Solidity: event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value) +func (_ConditionTokens *ConditionTokensFilterer) ParseTransferSingle(log types.Log) (*ConditionTokensTransferSingle, error) { + event := new(ConditionTokensTransferSingle) + if err := _ConditionTokens.contract.UnpackLog(event, "TransferSingle", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ConditionTokensURIIterator is returned from FilterURI and is used to iterate over the raw logs and unpacked data for URI events raised by the ConditionTokens contract. +type ConditionTokensURIIterator struct { + Event *ConditionTokensURI // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ConditionTokensURIIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ConditionTokensURI) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ConditionTokensURI) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ConditionTokensURIIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ConditionTokensURIIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ConditionTokensURI represents a URI event raised by the ConditionTokens contract. +type ConditionTokensURI struct { + Value string + Id *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterURI is a free log retrieval operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b. +// +// Solidity: event URI(string value, uint256 indexed id) +func (_ConditionTokens *ConditionTokensFilterer) FilterURI(opts *bind.FilterOpts, id []*big.Int) (*ConditionTokensURIIterator, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + + logs, sub, err := _ConditionTokens.contract.FilterLogs(opts, "URI", idRule) + if err != nil { + return nil, err + } + return &ConditionTokensURIIterator{contract: _ConditionTokens.contract, event: "URI", logs: logs, sub: sub}, nil +} + +// WatchURI is a free log subscription operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b. +// +// Solidity: event URI(string value, uint256 indexed id) +func (_ConditionTokens *ConditionTokensFilterer) WatchURI(opts *bind.WatchOpts, sink chan<- *ConditionTokensURI, id []*big.Int) (event.Subscription, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + + logs, sub, err := _ConditionTokens.contract.WatchLogs(opts, "URI", idRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ConditionTokensURI) + if err := _ConditionTokens.contract.UnpackLog(event, "URI", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseURI is a log parse operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b. +// +// Solidity: event URI(string value, uint256 indexed id) +func (_ConditionTokens *ConditionTokensFilterer) ParseURI(log types.Log) (*ConditionTokensURI, error) { + event := new(ConditionTokensURI) + if err := _ConditionTokens.contract.UnpackLog(event, "URI", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} From 7b24ccfe940a21ce8f2532a6add3f4a4cc89333e Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 17:43:29 +0800 Subject: [PATCH 09/19] fix: add generated contract go files #2 --- .../polymarket/contract_ctf_exchange.go | 3566 +++++++++++++++++ 1 file changed, 3566 insertions(+) create mode 100644 provider/ethereum/contract/polymarket/contract_ctf_exchange.go diff --git a/provider/ethereum/contract/polymarket/contract_ctf_exchange.go b/provider/ethereum/contract/polymarket/contract_ctf_exchange.go new file mode 100644 index 00000000..5e50527c --- /dev/null +++ b/provider/ethereum/contract/polymarket/contract_ctf_exchange.go @@ -0,0 +1,3566 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polymarket + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// Order is an auto generated low-level Go binding around an user-defined struct. +type Order struct { + Salt *big.Int + Maker common.Address + Signer common.Address + Taker common.Address + TokenId *big.Int + MakerAmount *big.Int + TakerAmount *big.Int + Expiration *big.Int + Nonce *big.Int + FeeRateBps *big.Int + Side uint8 + SignatureType uint8 + Signature []byte +} + +// OrderStatus is an auto generated low-level Go binding around an user-defined struct. +type OrderStatus struct { + IsFilledOrCancelled bool + Remaining *big.Int +} + +// CTFExchangeMetaData contains all meta data concerning the CTFExchange contract. +var CTFExchangeMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_ctf\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_proxyFactory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_safeFactory\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FeeTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidComplement\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenId\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MakingGtRemaining\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MismatchedTokenIds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCrossing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOperator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderFilledOrCancelled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLittleTokensReceived\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"FeeCharged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newAdminAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOperatorAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderCancelled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"OrderFilled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"takerOrderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"takerOrderMaker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"}],\"name\":\"OrdersMatched\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldProxyFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProxyFactory\",\"type\":\"address\"}],\"name\":\"ProxyFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedAdmin\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedOperator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldSafeFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newSafeFactory\",\"type\":\"address\"}],\"name\":\"SafeFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token0\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"TokenRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingUnpaused\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"name\":\"addAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator_\",\"type\":\"address\"}],\"name\":\"addOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"admins\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"cancelOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"cancelOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"domainSeparator\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"fillAmount\",\"type\":\"uint256\"}],\"name\":\"fillOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"fillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"fillOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateral\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getComplement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCtf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getMaxFeeRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"getOrderStatus\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"internalType\":\"structOrderStatus\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPolyProxyFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getPolyProxyWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getProxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getSafeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isAdmin\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"isValidNonce\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"takerOrder\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"makerOrders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"takerFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"makerFillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"matchOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"operators\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"orderStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parentCollectionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"registerToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"removeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"removeOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOperatorRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"safeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProxyFactory\",\"type\":\"address\"}],\"name\":\"setProxyFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newSafeFactory\",\"type\":\"address\"}],\"name\":\"setSafeFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"}],\"name\":\"validateComplement\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrder\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrderSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"validateTokenId\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// CTFExchangeABI is the input ABI used to generate the binding from. +// Deprecated: Use CTFExchangeMetaData.ABI instead. +var CTFExchangeABI = CTFExchangeMetaData.ABI + +// CTFExchange is an auto generated Go binding around an Ethereum contract. +type CTFExchange struct { + CTFExchangeCaller // Read-only binding to the contract + CTFExchangeTransactor // Write-only binding to the contract + CTFExchangeFilterer // Log filterer for contract events +} + +// CTFExchangeCaller is an auto generated read-only Go binding around an Ethereum contract. +type CTFExchangeCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// CTFExchangeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type CTFExchangeTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// CTFExchangeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type CTFExchangeFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// CTFExchangeSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type CTFExchangeSession struct { + Contract *CTFExchange // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// CTFExchangeCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type CTFExchangeCallerSession struct { + Contract *CTFExchangeCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// CTFExchangeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type CTFExchangeTransactorSession struct { + Contract *CTFExchangeTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// CTFExchangeRaw is an auto generated low-level Go binding around an Ethereum contract. +type CTFExchangeRaw struct { + Contract *CTFExchange // Generic contract binding to access the raw methods on +} + +// CTFExchangeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type CTFExchangeCallerRaw struct { + Contract *CTFExchangeCaller // Generic read-only contract binding to access the raw methods on +} + +// CTFExchangeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type CTFExchangeTransactorRaw struct { + Contract *CTFExchangeTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewCTFExchange creates a new instance of CTFExchange, bound to a specific deployed contract. +func NewCTFExchange(address common.Address, backend bind.ContractBackend) (*CTFExchange, error) { + contract, err := bindCTFExchange(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &CTFExchange{CTFExchangeCaller: CTFExchangeCaller{contract: contract}, CTFExchangeTransactor: CTFExchangeTransactor{contract: contract}, CTFExchangeFilterer: CTFExchangeFilterer{contract: contract}}, nil +} + +// NewCTFExchangeCaller creates a new read-only instance of CTFExchange, bound to a specific deployed contract. +func NewCTFExchangeCaller(address common.Address, caller bind.ContractCaller) (*CTFExchangeCaller, error) { + contract, err := bindCTFExchange(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &CTFExchangeCaller{contract: contract}, nil +} + +// NewCTFExchangeTransactor creates a new write-only instance of CTFExchange, bound to a specific deployed contract. +func NewCTFExchangeTransactor(address common.Address, transactor bind.ContractTransactor) (*CTFExchangeTransactor, error) { + contract, err := bindCTFExchange(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &CTFExchangeTransactor{contract: contract}, nil +} + +// NewCTFExchangeFilterer creates a new log filterer instance of CTFExchange, bound to a specific deployed contract. +func NewCTFExchangeFilterer(address common.Address, filterer bind.ContractFilterer) (*CTFExchangeFilterer, error) { + contract, err := bindCTFExchange(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &CTFExchangeFilterer{contract: contract}, nil +} + +// bindCTFExchange binds a generic wrapper to an already deployed contract. +func bindCTFExchange(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := CTFExchangeMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_CTFExchange *CTFExchangeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _CTFExchange.Contract.CTFExchangeCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_CTFExchange *CTFExchangeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.Contract.CTFExchangeTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_CTFExchange *CTFExchangeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _CTFExchange.Contract.CTFExchangeTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_CTFExchange *CTFExchangeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _CTFExchange.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_CTFExchange *CTFExchangeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_CTFExchange *CTFExchangeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _CTFExchange.Contract.contract.Transact(opts, method, params...) +} + +// Admins is a free data retrieval call binding the contract method 0x429b62e5. +// +// Solidity: function admins(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCaller) Admins(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "admins", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Admins is a free data retrieval call binding the contract method 0x429b62e5. +// +// Solidity: function admins(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeSession) Admins(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Admins(&_CTFExchange.CallOpts, arg0) +} + +// Admins is a free data retrieval call binding the contract method 0x429b62e5. +// +// Solidity: function admins(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) Admins(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Admins(&_CTFExchange.CallOpts, arg0) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_CTFExchange *CTFExchangeCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "domainSeparator") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_CTFExchange *CTFExchangeSession) DomainSeparator() ([32]byte, error) { + return _CTFExchange.Contract.DomainSeparator(&_CTFExchange.CallOpts) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_CTFExchange *CTFExchangeCallerSession) DomainSeparator() ([32]byte, error) { + return _CTFExchange.Contract.DomainSeparator(&_CTFExchange.CallOpts) +} + +// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. +// +// Solidity: function getCollateral() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetCollateral(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getCollateral") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. +// +// Solidity: function getCollateral() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetCollateral() (common.Address, error) { + return _CTFExchange.Contract.GetCollateral(&_CTFExchange.CallOpts) +} + +// GetCollateral is a free data retrieval call binding the contract method 0x5c1548fb. +// +// Solidity: function getCollateral() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetCollateral() (common.Address, error) { + return _CTFExchange.Contract.GetCollateral(&_CTFExchange.CallOpts) +} + +// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. +// +// Solidity: function getComplement(uint256 token) view returns(uint256) +func (_CTFExchange *CTFExchangeCaller) GetComplement(opts *bind.CallOpts, token *big.Int) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getComplement", token) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. +// +// Solidity: function getComplement(uint256 token) view returns(uint256) +func (_CTFExchange *CTFExchangeSession) GetComplement(token *big.Int) (*big.Int, error) { + return _CTFExchange.Contract.GetComplement(&_CTFExchange.CallOpts, token) +} + +// GetComplement is a free data retrieval call binding the contract method 0xa10f3dce. +// +// Solidity: function getComplement(uint256 token) view returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) GetComplement(token *big.Int) (*big.Int, error) { + return _CTFExchange.Contract.GetComplement(&_CTFExchange.CallOpts, token) +} + +// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. +// +// Solidity: function getConditionId(uint256 token) view returns(bytes32) +func (_CTFExchange *CTFExchangeCaller) GetConditionId(opts *bind.CallOpts, token *big.Int) ([32]byte, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getConditionId", token) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. +// +// Solidity: function getConditionId(uint256 token) view returns(bytes32) +func (_CTFExchange *CTFExchangeSession) GetConditionId(token *big.Int) ([32]byte, error) { + return _CTFExchange.Contract.GetConditionId(&_CTFExchange.CallOpts, token) +} + +// GetConditionId is a free data retrieval call binding the contract method 0xd7fb272f. +// +// Solidity: function getConditionId(uint256 token) view returns(bytes32) +func (_CTFExchange *CTFExchangeCallerSession) GetConditionId(token *big.Int) ([32]byte, error) { + return _CTFExchange.Contract.GetConditionId(&_CTFExchange.CallOpts, token) +} + +// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. +// +// Solidity: function getCtf() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetCtf(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getCtf") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. +// +// Solidity: function getCtf() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetCtf() (common.Address, error) { + return _CTFExchange.Contract.GetCtf(&_CTFExchange.CallOpts) +} + +// GetCtf is a free data retrieval call binding the contract method 0x3b521d78. +// +// Solidity: function getCtf() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetCtf() (common.Address, error) { + return _CTFExchange.Contract.GetCtf(&_CTFExchange.CallOpts) +} + +// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. +// +// Solidity: function getMaxFeeRate() pure returns(uint256) +func (_CTFExchange *CTFExchangeCaller) GetMaxFeeRate(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getMaxFeeRate") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. +// +// Solidity: function getMaxFeeRate() pure returns(uint256) +func (_CTFExchange *CTFExchangeSession) GetMaxFeeRate() (*big.Int, error) { + return _CTFExchange.Contract.GetMaxFeeRate(&_CTFExchange.CallOpts) +} + +// GetMaxFeeRate is a free data retrieval call binding the contract method 0x4a2a11f5. +// +// Solidity: function getMaxFeeRate() pure returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) GetMaxFeeRate() (*big.Int, error) { + return _CTFExchange.Contract.GetMaxFeeRate(&_CTFExchange.CallOpts) +} + +// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. +// +// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) +func (_CTFExchange *CTFExchangeCaller) GetOrderStatus(opts *bind.CallOpts, orderHash [32]byte) (OrderStatus, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getOrderStatus", orderHash) + + if err != nil { + return *new(OrderStatus), err + } + + out0 := *abi.ConvertType(out[0], new(OrderStatus)).(*OrderStatus) + + return out0, err + +} + +// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. +// +// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) +func (_CTFExchange *CTFExchangeSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { + return _CTFExchange.Contract.GetOrderStatus(&_CTFExchange.CallOpts, orderHash) +} + +// GetOrderStatus is a free data retrieval call binding the contract method 0x46423aa7. +// +// Solidity: function getOrderStatus(bytes32 orderHash) view returns((bool,uint256)) +func (_CTFExchange *CTFExchangeCallerSession) GetOrderStatus(orderHash [32]byte) (OrderStatus, error) { + return _CTFExchange.Contract.GetOrderStatus(&_CTFExchange.CallOpts, orderHash) +} + +// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. +// +// Solidity: function getPolyProxyFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetPolyProxyFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getPolyProxyFactoryImplementation") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. +// +// Solidity: function getPolyProxyFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetPolyProxyFactoryImplementation() (common.Address, error) { + return _CTFExchange.Contract.GetPolyProxyFactoryImplementation(&_CTFExchange.CallOpts) +} + +// GetPolyProxyFactoryImplementation is a free data retrieval call binding the contract method 0x06b9d691. +// +// Solidity: function getPolyProxyFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetPolyProxyFactoryImplementation() (common.Address, error) { + return _CTFExchange.Contract.GetPolyProxyFactoryImplementation(&_CTFExchange.CallOpts) +} + +// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. +// +// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetPolyProxyWalletAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getPolyProxyWalletAddress", _addr) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. +// +// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { + return _CTFExchange.Contract.GetPolyProxyWalletAddress(&_CTFExchange.CallOpts, _addr) +} + +// GetPolyProxyWalletAddress is a free data retrieval call binding the contract method 0xedef7d8e. +// +// Solidity: function getPolyProxyWalletAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetPolyProxyWalletAddress(_addr common.Address) (common.Address, error) { + return _CTFExchange.Contract.GetPolyProxyWalletAddress(&_CTFExchange.CallOpts, _addr) +} + +// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. +// +// Solidity: function getProxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetProxyFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getProxyFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. +// +// Solidity: function getProxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetProxyFactory() (common.Address, error) { + return _CTFExchange.Contract.GetProxyFactory(&_CTFExchange.CallOpts) +} + +// GetProxyFactory is a free data retrieval call binding the contract method 0xb28c51c0. +// +// Solidity: function getProxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetProxyFactory() (common.Address, error) { + return _CTFExchange.Contract.GetProxyFactory(&_CTFExchange.CallOpts) +} + +// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. +// +// Solidity: function getSafeAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetSafeAddress(opts *bind.CallOpts, _addr common.Address) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getSafeAddress", _addr) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. +// +// Solidity: function getSafeAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeSession) GetSafeAddress(_addr common.Address) (common.Address, error) { + return _CTFExchange.Contract.GetSafeAddress(&_CTFExchange.CallOpts, _addr) +} + +// GetSafeAddress is a free data retrieval call binding the contract method 0xa287bdf1. +// +// Solidity: function getSafeAddress(address _addr) view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetSafeAddress(_addr common.Address) (common.Address, error) { + return _CTFExchange.Contract.GetSafeAddress(&_CTFExchange.CallOpts, _addr) +} + +// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. +// +// Solidity: function getSafeFactory() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetSafeFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getSafeFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. +// +// Solidity: function getSafeFactory() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetSafeFactory() (common.Address, error) { + return _CTFExchange.Contract.GetSafeFactory(&_CTFExchange.CallOpts) +} + +// GetSafeFactory is a free data retrieval call binding the contract method 0x75d7370a. +// +// Solidity: function getSafeFactory() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetSafeFactory() (common.Address, error) { + return _CTFExchange.Contract.GetSafeFactory(&_CTFExchange.CallOpts) +} + +// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. +// +// Solidity: function getSafeFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeCaller) GetSafeFactoryImplementation(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "getSafeFactoryImplementation") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. +// +// Solidity: function getSafeFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeSession) GetSafeFactoryImplementation() (common.Address, error) { + return _CTFExchange.Contract.GetSafeFactoryImplementation(&_CTFExchange.CallOpts) +} + +// GetSafeFactoryImplementation is a free data retrieval call binding the contract method 0xe03ac3d0. +// +// Solidity: function getSafeFactoryImplementation() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) GetSafeFactoryImplementation() (common.Address, error) { + return _CTFExchange.Contract.GetSafeFactoryImplementation(&_CTFExchange.CallOpts) +} + +// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. +// +// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) +func (_CTFExchange *CTFExchangeCaller) HashOrder(opts *bind.CallOpts, order Order) ([32]byte, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "hashOrder", order) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. +// +// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) +func (_CTFExchange *CTFExchangeSession) HashOrder(order Order) ([32]byte, error) { + return _CTFExchange.Contract.HashOrder(&_CTFExchange.CallOpts, order) +} + +// HashOrder is a free data retrieval call binding the contract method 0xe50e4f97. +// +// Solidity: function hashOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns(bytes32) +func (_CTFExchange *CTFExchangeCallerSession) HashOrder(order Order) ([32]byte, error) { + return _CTFExchange.Contract.HashOrder(&_CTFExchange.CallOpts, order) +} + +// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. +// +// Solidity: function isAdmin(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeCaller) IsAdmin(opts *bind.CallOpts, usr common.Address) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "isAdmin", usr) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. +// +// Solidity: function isAdmin(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeSession) IsAdmin(usr common.Address) (bool, error) { + return _CTFExchange.Contract.IsAdmin(&_CTFExchange.CallOpts, usr) +} + +// IsAdmin is a free data retrieval call binding the contract method 0x24d7806c. +// +// Solidity: function isAdmin(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) IsAdmin(usr common.Address) (bool, error) { + return _CTFExchange.Contract.IsAdmin(&_CTFExchange.CallOpts, usr) +} + +// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. +// +// Solidity: function isOperator(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeCaller) IsOperator(opts *bind.CallOpts, usr common.Address) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "isOperator", usr) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. +// +// Solidity: function isOperator(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeSession) IsOperator(usr common.Address) (bool, error) { + return _CTFExchange.Contract.IsOperator(&_CTFExchange.CallOpts, usr) +} + +// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. +// +// Solidity: function isOperator(address usr) view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) IsOperator(usr common.Address) (bool, error) { + return _CTFExchange.Contract.IsOperator(&_CTFExchange.CallOpts, usr) +} + +// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. +// +// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) +func (_CTFExchange *CTFExchangeCaller) IsValidNonce(opts *bind.CallOpts, usr common.Address, nonce *big.Int) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "isValidNonce", usr, nonce) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. +// +// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) +func (_CTFExchange *CTFExchangeSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { + return _CTFExchange.Contract.IsValidNonce(&_CTFExchange.CallOpts, usr, nonce) +} + +// IsValidNonce is a free data retrieval call binding the contract method 0x0647ee20. +// +// Solidity: function isValidNonce(address usr, uint256 nonce) view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) IsValidNonce(usr common.Address, nonce *big.Int) (bool, error) { + return _CTFExchange.Contract.IsValidNonce(&_CTFExchange.CallOpts, usr, nonce) +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "nonces", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeSession) Nonces(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Nonces(&_CTFExchange.CallOpts, arg0) +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) Nonces(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Nonces(&_CTFExchange.CallOpts, arg0) +} + +// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. +// +// Solidity: function operators(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCaller) Operators(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "operators", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. +// +// Solidity: function operators(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeSession) Operators(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Operators(&_CTFExchange.CallOpts, arg0) +} + +// Operators is a free data retrieval call binding the contract method 0x13e7c9d8. +// +// Solidity: function operators(address ) view returns(uint256) +func (_CTFExchange *CTFExchangeCallerSession) Operators(arg0 common.Address) (*big.Int, error) { + return _CTFExchange.Contract.Operators(&_CTFExchange.CallOpts, arg0) +} + +// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. +// +// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) +func (_CTFExchange *CTFExchangeCaller) OrderStatus(opts *bind.CallOpts, arg0 [32]byte) (struct { + IsFilledOrCancelled bool + Remaining *big.Int +}, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "orderStatus", arg0) + + outstruct := new(struct { + IsFilledOrCancelled bool + Remaining *big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.IsFilledOrCancelled = *abi.ConvertType(out[0], new(bool)).(*bool) + outstruct.Remaining = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. +// +// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) +func (_CTFExchange *CTFExchangeSession) OrderStatus(arg0 [32]byte) (struct { + IsFilledOrCancelled bool + Remaining *big.Int +}, error) { + return _CTFExchange.Contract.OrderStatus(&_CTFExchange.CallOpts, arg0) +} + +// OrderStatus is a free data retrieval call binding the contract method 0x2dff692d. +// +// Solidity: function orderStatus(bytes32 ) view returns(bool isFilledOrCancelled, uint256 remaining) +func (_CTFExchange *CTFExchangeCallerSession) OrderStatus(arg0 [32]byte) (struct { + IsFilledOrCancelled bool + Remaining *big.Int +}, error) { + return _CTFExchange.Contract.OrderStatus(&_CTFExchange.CallOpts, arg0) +} + +// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. +// +// Solidity: function parentCollectionId() view returns(bytes32) +func (_CTFExchange *CTFExchangeCaller) ParentCollectionId(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "parentCollectionId") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. +// +// Solidity: function parentCollectionId() view returns(bytes32) +func (_CTFExchange *CTFExchangeSession) ParentCollectionId() ([32]byte, error) { + return _CTFExchange.Contract.ParentCollectionId(&_CTFExchange.CallOpts) +} + +// ParentCollectionId is a free data retrieval call binding the contract method 0x44bea37e. +// +// Solidity: function parentCollectionId() view returns(bytes32) +func (_CTFExchange *CTFExchangeCallerSession) ParentCollectionId() ([32]byte, error) { + return _CTFExchange.Contract.ParentCollectionId(&_CTFExchange.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_CTFExchange *CTFExchangeCaller) Paused(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "paused") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_CTFExchange *CTFExchangeSession) Paused() (bool, error) { + return _CTFExchange.Contract.Paused(&_CTFExchange.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) Paused() (bool, error) { + return _CTFExchange.Contract.Paused(&_CTFExchange.CallOpts) +} + +// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. +// +// Solidity: function proxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeCaller) ProxyFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "proxyFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. +// +// Solidity: function proxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeSession) ProxyFactory() (common.Address, error) { + return _CTFExchange.Contract.ProxyFactory(&_CTFExchange.CallOpts) +} + +// ProxyFactory is a free data retrieval call binding the contract method 0xc10f1a75. +// +// Solidity: function proxyFactory() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) ProxyFactory() (common.Address, error) { + return _CTFExchange.Contract.ProxyFactory(&_CTFExchange.CallOpts) +} + +// Registry is a free data retrieval call binding the contract method 0x5893253c. +// +// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) +func (_CTFExchange *CTFExchangeCaller) Registry(opts *bind.CallOpts, arg0 *big.Int) (struct { + Complement *big.Int + ConditionId [32]byte +}, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "registry", arg0) + + outstruct := new(struct { + Complement *big.Int + ConditionId [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.Complement = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.ConditionId = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// Registry is a free data retrieval call binding the contract method 0x5893253c. +// +// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) +func (_CTFExchange *CTFExchangeSession) Registry(arg0 *big.Int) (struct { + Complement *big.Int + ConditionId [32]byte +}, error) { + return _CTFExchange.Contract.Registry(&_CTFExchange.CallOpts, arg0) +} + +// Registry is a free data retrieval call binding the contract method 0x5893253c. +// +// Solidity: function registry(uint256 ) view returns(uint256 complement, bytes32 conditionId) +func (_CTFExchange *CTFExchangeCallerSession) Registry(arg0 *big.Int) (struct { + Complement *big.Int + ConditionId [32]byte +}, error) { + return _CTFExchange.Contract.Registry(&_CTFExchange.CallOpts, arg0) +} + +// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. +// +// Solidity: function safeFactory() view returns(address) +func (_CTFExchange *CTFExchangeCaller) SafeFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "safeFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. +// +// Solidity: function safeFactory() view returns(address) +func (_CTFExchange *CTFExchangeSession) SafeFactory() (common.Address, error) { + return _CTFExchange.Contract.SafeFactory(&_CTFExchange.CallOpts) +} + +// SafeFactory is a free data retrieval call binding the contract method 0x131e7e1c. +// +// Solidity: function safeFactory() view returns(address) +func (_CTFExchange *CTFExchangeCallerSession) SafeFactory() (common.Address, error) { + return _CTFExchange.Contract.SafeFactory(&_CTFExchange.CallOpts) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_CTFExchange *CTFExchangeCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "supportsInterface", interfaceId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_CTFExchange *CTFExchangeSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _CTFExchange.Contract.SupportsInterface(&_CTFExchange.CallOpts, interfaceId) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_CTFExchange *CTFExchangeCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _CTFExchange.Contract.SupportsInterface(&_CTFExchange.CallOpts, interfaceId) +} + +// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. +// +// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() +func (_CTFExchange *CTFExchangeCaller) ValidateComplement(opts *bind.CallOpts, token *big.Int, complement *big.Int) error { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "validateComplement", token, complement) + + if err != nil { + return err + } + + return err + +} + +// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. +// +// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() +func (_CTFExchange *CTFExchangeSession) ValidateComplement(token *big.Int, complement *big.Int) error { + return _CTFExchange.Contract.ValidateComplement(&_CTFExchange.CallOpts, token, complement) +} + +// ValidateComplement is a free data retrieval call binding the contract method 0xd82da838. +// +// Solidity: function validateComplement(uint256 token, uint256 complement) view returns() +func (_CTFExchange *CTFExchangeCallerSession) ValidateComplement(token *big.Int, complement *big.Int) error { + return _CTFExchange.Contract.ValidateComplement(&_CTFExchange.CallOpts, token, complement) +} + +// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. +// +// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeCaller) ValidateOrder(opts *bind.CallOpts, order Order) error { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "validateOrder", order) + + if err != nil { + return err + } + + return err + +} + +// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. +// +// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeSession) ValidateOrder(order Order) error { + return _CTFExchange.Contract.ValidateOrder(&_CTFExchange.CallOpts, order) +} + +// ValidateOrder is a free data retrieval call binding the contract method 0x654f0ce4. +// +// Solidity: function validateOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeCallerSession) ValidateOrder(order Order) error { + return _CTFExchange.Contract.ValidateOrder(&_CTFExchange.CallOpts, order) +} + +// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. +// +// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeCaller) ValidateOrderSignature(opts *bind.CallOpts, orderHash [32]byte, order Order) error { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "validateOrderSignature", orderHash, order) + + if err != nil { + return err + } + + return err + +} + +// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. +// +// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { + return _CTFExchange.Contract.ValidateOrderSignature(&_CTFExchange.CallOpts, orderHash, order) +} + +// ValidateOrderSignature is a free data retrieval call binding the contract method 0xe2eec405. +// +// Solidity: function validateOrderSignature(bytes32 orderHash, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) view returns() +func (_CTFExchange *CTFExchangeCallerSession) ValidateOrderSignature(orderHash [32]byte, order Order) error { + return _CTFExchange.Contract.ValidateOrderSignature(&_CTFExchange.CallOpts, orderHash, order) +} + +// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. +// +// Solidity: function validateTokenId(uint256 tokenId) view returns() +func (_CTFExchange *CTFExchangeCaller) ValidateTokenId(opts *bind.CallOpts, tokenId *big.Int) error { + var out []interface{} + err := _CTFExchange.contract.Call(opts, &out, "validateTokenId", tokenId) + + if err != nil { + return err + } + + return err + +} + +// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. +// +// Solidity: function validateTokenId(uint256 tokenId) view returns() +func (_CTFExchange *CTFExchangeSession) ValidateTokenId(tokenId *big.Int) error { + return _CTFExchange.Contract.ValidateTokenId(&_CTFExchange.CallOpts, tokenId) +} + +// ValidateTokenId is a free data retrieval call binding the contract method 0x34600901. +// +// Solidity: function validateTokenId(uint256 tokenId) view returns() +func (_CTFExchange *CTFExchangeCallerSession) ValidateTokenId(tokenId *big.Int) error { + return _CTFExchange.Contract.ValidateTokenId(&_CTFExchange.CallOpts, tokenId) +} + +// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. +// +// Solidity: function addAdmin(address admin_) returns() +func (_CTFExchange *CTFExchangeTransactor) AddAdmin(opts *bind.TransactOpts, admin_ common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "addAdmin", admin_) +} + +// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. +// +// Solidity: function addAdmin(address admin_) returns() +func (_CTFExchange *CTFExchangeSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.AddAdmin(&_CTFExchange.TransactOpts, admin_) +} + +// AddAdmin is a paid mutator transaction binding the contract method 0x70480275. +// +// Solidity: function addAdmin(address admin_) returns() +func (_CTFExchange *CTFExchangeTransactorSession) AddAdmin(admin_ common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.AddAdmin(&_CTFExchange.TransactOpts, admin_) +} + +// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. +// +// Solidity: function addOperator(address operator_) returns() +func (_CTFExchange *CTFExchangeTransactor) AddOperator(opts *bind.TransactOpts, operator_ common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "addOperator", operator_) +} + +// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. +// +// Solidity: function addOperator(address operator_) returns() +func (_CTFExchange *CTFExchangeSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.AddOperator(&_CTFExchange.TransactOpts, operator_) +} + +// AddOperator is a paid mutator transaction binding the contract method 0x9870d7fe. +// +// Solidity: function addOperator(address operator_) returns() +func (_CTFExchange *CTFExchangeTransactorSession) AddOperator(operator_ common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.AddOperator(&_CTFExchange.TransactOpts, operator_) +} + +// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. +// +// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() +func (_CTFExchange *CTFExchangeTransactor) CancelOrder(opts *bind.TransactOpts, order Order) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "cancelOrder", order) +} + +// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. +// +// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() +func (_CTFExchange *CTFExchangeSession) CancelOrder(order Order) (*types.Transaction, error) { + return _CTFExchange.Contract.CancelOrder(&_CTFExchange.TransactOpts, order) +} + +// CancelOrder is a paid mutator transaction binding the contract method 0xa6dfcf86. +// +// Solidity: function cancelOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order) returns() +func (_CTFExchange *CTFExchangeTransactorSession) CancelOrder(order Order) (*types.Transaction, error) { + return _CTFExchange.Contract.CancelOrder(&_CTFExchange.TransactOpts, order) +} + +// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. +// +// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() +func (_CTFExchange *CTFExchangeTransactor) CancelOrders(opts *bind.TransactOpts, orders []Order) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "cancelOrders", orders) +} + +// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. +// +// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() +func (_CTFExchange *CTFExchangeSession) CancelOrders(orders []Order) (*types.Transaction, error) { + return _CTFExchange.Contract.CancelOrders(&_CTFExchange.TransactOpts, orders) +} + +// CancelOrders is a paid mutator transaction binding the contract method 0xfa950b48. +// +// Solidity: function cancelOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders) returns() +func (_CTFExchange *CTFExchangeTransactorSession) CancelOrders(orders []Order) (*types.Transaction, error) { + return _CTFExchange.Contract.CancelOrders(&_CTFExchange.TransactOpts, orders) +} + +// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. +// +// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() +func (_CTFExchange *CTFExchangeTransactor) FillOrder(opts *bind.TransactOpts, order Order, fillAmount *big.Int) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "fillOrder", order, fillAmount) +} + +// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. +// +// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() +func (_CTFExchange *CTFExchangeSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.FillOrder(&_CTFExchange.TransactOpts, order, fillAmount) +} + +// FillOrder is a paid mutator transaction binding the contract method 0xfe729aaf. +// +// Solidity: function fillOrder((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) order, uint256 fillAmount) returns() +func (_CTFExchange *CTFExchangeTransactorSession) FillOrder(order Order, fillAmount *big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.FillOrder(&_CTFExchange.TransactOpts, order, fillAmount) +} + +// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. +// +// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() +func (_CTFExchange *CTFExchangeTransactor) FillOrders(opts *bind.TransactOpts, orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "fillOrders", orders, fillAmounts) +} + +// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. +// +// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() +func (_CTFExchange *CTFExchangeSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.FillOrders(&_CTFExchange.TransactOpts, orders, fillAmounts) +} + +// FillOrders is a paid mutator transaction binding the contract method 0xd798eff6. +// +// Solidity: function fillOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] orders, uint256[] fillAmounts) returns() +func (_CTFExchange *CTFExchangeTransactorSession) FillOrders(orders []Order, fillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.FillOrders(&_CTFExchange.TransactOpts, orders, fillAmounts) +} + +// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. +// +// Solidity: function incrementNonce() returns() +func (_CTFExchange *CTFExchangeTransactor) IncrementNonce(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "incrementNonce") +} + +// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. +// +// Solidity: function incrementNonce() returns() +func (_CTFExchange *CTFExchangeSession) IncrementNonce() (*types.Transaction, error) { + return _CTFExchange.Contract.IncrementNonce(&_CTFExchange.TransactOpts) +} + +// IncrementNonce is a paid mutator transaction binding the contract method 0x627cdcb9. +// +// Solidity: function incrementNonce() returns() +func (_CTFExchange *CTFExchangeTransactorSession) IncrementNonce() (*types.Transaction, error) { + return _CTFExchange.Contract.IncrementNonce(&_CTFExchange.TransactOpts) +} + +// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. +// +// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() +func (_CTFExchange *CTFExchangeTransactor) MatchOrders(opts *bind.TransactOpts, takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "matchOrders", takerOrder, makerOrders, takerFillAmount, makerFillAmounts) +} + +// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. +// +// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() +func (_CTFExchange *CTFExchangeSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.MatchOrders(&_CTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) +} + +// MatchOrders is a paid mutator transaction binding the contract method 0xe60f0c05. +// +// Solidity: function matchOrders((uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes) takerOrder, (uint256,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8,uint8,bytes)[] makerOrders, uint256 takerFillAmount, uint256[] makerFillAmounts) returns() +func (_CTFExchange *CTFExchangeTransactorSession) MatchOrders(takerOrder Order, makerOrders []Order, takerFillAmount *big.Int, makerFillAmounts []*big.Int) (*types.Transaction, error) { + return _CTFExchange.Contract.MatchOrders(&_CTFExchange.TransactOpts, takerOrder, makerOrders, takerFillAmount, makerFillAmounts) +} + +// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. +// +// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeTransactor) OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "onERC1155BatchReceived", arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. +// +// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.Contract.OnERC1155BatchReceived(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155BatchReceived is a paid mutator transaction binding the contract method 0xbc197c81. +// +// Solidity: function onERC1155BatchReceived(address , address , uint256[] , uint256[] , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeTransactorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.Contract.OnERC1155BatchReceived(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. +// +// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeTransactor) OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "onERC1155Received", arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. +// +// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.Contract.OnERC1155Received(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// OnERC1155Received is a paid mutator transaction binding the contract method 0xf23a6e61. +// +// Solidity: function onERC1155Received(address , address , uint256 , uint256 , bytes ) returns(bytes4) +func (_CTFExchange *CTFExchangeTransactorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _CTFExchange.Contract.OnERC1155Received(&_CTFExchange.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. +// +// Solidity: function pauseTrading() returns() +func (_CTFExchange *CTFExchangeTransactor) PauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "pauseTrading") +} + +// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. +// +// Solidity: function pauseTrading() returns() +func (_CTFExchange *CTFExchangeSession) PauseTrading() (*types.Transaction, error) { + return _CTFExchange.Contract.PauseTrading(&_CTFExchange.TransactOpts) +} + +// PauseTrading is a paid mutator transaction binding the contract method 0x1031e36e. +// +// Solidity: function pauseTrading() returns() +func (_CTFExchange *CTFExchangeTransactorSession) PauseTrading() (*types.Transaction, error) { + return _CTFExchange.Contract.PauseTrading(&_CTFExchange.TransactOpts) +} + +// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. +// +// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() +func (_CTFExchange *CTFExchangeTransactor) RegisterToken(opts *bind.TransactOpts, token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "registerToken", token, complement, conditionId) +} + +// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. +// +// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() +func (_CTFExchange *CTFExchangeSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { + return _CTFExchange.Contract.RegisterToken(&_CTFExchange.TransactOpts, token, complement, conditionId) +} + +// RegisterToken is a paid mutator transaction binding the contract method 0x68c7450f. +// +// Solidity: function registerToken(uint256 token, uint256 complement, bytes32 conditionId) returns() +func (_CTFExchange *CTFExchangeTransactorSession) RegisterToken(token *big.Int, complement *big.Int, conditionId [32]byte) (*types.Transaction, error) { + return _CTFExchange.Contract.RegisterToken(&_CTFExchange.TransactOpts, token, complement, conditionId) +} + +// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. +// +// Solidity: function removeAdmin(address admin) returns() +func (_CTFExchange *CTFExchangeTransactor) RemoveAdmin(opts *bind.TransactOpts, admin common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "removeAdmin", admin) +} + +// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. +// +// Solidity: function removeAdmin(address admin) returns() +func (_CTFExchange *CTFExchangeSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.RemoveAdmin(&_CTFExchange.TransactOpts, admin) +} + +// RemoveAdmin is a paid mutator transaction binding the contract method 0x1785f53c. +// +// Solidity: function removeAdmin(address admin) returns() +func (_CTFExchange *CTFExchangeTransactorSession) RemoveAdmin(admin common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.RemoveAdmin(&_CTFExchange.TransactOpts, admin) +} + +// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. +// +// Solidity: function removeOperator(address operator) returns() +func (_CTFExchange *CTFExchangeTransactor) RemoveOperator(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "removeOperator", operator) +} + +// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. +// +// Solidity: function removeOperator(address operator) returns() +func (_CTFExchange *CTFExchangeSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.RemoveOperator(&_CTFExchange.TransactOpts, operator) +} + +// RemoveOperator is a paid mutator transaction binding the contract method 0xac8a584a. +// +// Solidity: function removeOperator(address operator) returns() +func (_CTFExchange *CTFExchangeTransactorSession) RemoveOperator(operator common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.RemoveOperator(&_CTFExchange.TransactOpts, operator) +} + +// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. +// +// Solidity: function renounceAdminRole() returns() +func (_CTFExchange *CTFExchangeTransactor) RenounceAdminRole(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "renounceAdminRole") +} + +// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. +// +// Solidity: function renounceAdminRole() returns() +func (_CTFExchange *CTFExchangeSession) RenounceAdminRole() (*types.Transaction, error) { + return _CTFExchange.Contract.RenounceAdminRole(&_CTFExchange.TransactOpts) +} + +// RenounceAdminRole is a paid mutator transaction binding the contract method 0x83b8a5ae. +// +// Solidity: function renounceAdminRole() returns() +func (_CTFExchange *CTFExchangeTransactorSession) RenounceAdminRole() (*types.Transaction, error) { + return _CTFExchange.Contract.RenounceAdminRole(&_CTFExchange.TransactOpts) +} + +// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. +// +// Solidity: function renounceOperatorRole() returns() +func (_CTFExchange *CTFExchangeTransactor) RenounceOperatorRole(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "renounceOperatorRole") +} + +// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. +// +// Solidity: function renounceOperatorRole() returns() +func (_CTFExchange *CTFExchangeSession) RenounceOperatorRole() (*types.Transaction, error) { + return _CTFExchange.Contract.RenounceOperatorRole(&_CTFExchange.TransactOpts) +} + +// RenounceOperatorRole is a paid mutator transaction binding the contract method 0x3d6d3598. +// +// Solidity: function renounceOperatorRole() returns() +func (_CTFExchange *CTFExchangeTransactorSession) RenounceOperatorRole() (*types.Transaction, error) { + return _CTFExchange.Contract.RenounceOperatorRole(&_CTFExchange.TransactOpts) +} + +// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. +// +// Solidity: function setProxyFactory(address _newProxyFactory) returns() +func (_CTFExchange *CTFExchangeTransactor) SetProxyFactory(opts *bind.TransactOpts, _newProxyFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "setProxyFactory", _newProxyFactory) +} + +// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. +// +// Solidity: function setProxyFactory(address _newProxyFactory) returns() +func (_CTFExchange *CTFExchangeSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.SetProxyFactory(&_CTFExchange.TransactOpts, _newProxyFactory) +} + +// SetProxyFactory is a paid mutator transaction binding the contract method 0xfbddd751. +// +// Solidity: function setProxyFactory(address _newProxyFactory) returns() +func (_CTFExchange *CTFExchangeTransactorSession) SetProxyFactory(_newProxyFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.SetProxyFactory(&_CTFExchange.TransactOpts, _newProxyFactory) +} + +// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. +// +// Solidity: function setSafeFactory(address _newSafeFactory) returns() +func (_CTFExchange *CTFExchangeTransactor) SetSafeFactory(opts *bind.TransactOpts, _newSafeFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "setSafeFactory", _newSafeFactory) +} + +// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. +// +// Solidity: function setSafeFactory(address _newSafeFactory) returns() +func (_CTFExchange *CTFExchangeSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.SetSafeFactory(&_CTFExchange.TransactOpts, _newSafeFactory) +} + +// SetSafeFactory is a paid mutator transaction binding the contract method 0x4544f055. +// +// Solidity: function setSafeFactory(address _newSafeFactory) returns() +func (_CTFExchange *CTFExchangeTransactorSession) SetSafeFactory(_newSafeFactory common.Address) (*types.Transaction, error) { + return _CTFExchange.Contract.SetSafeFactory(&_CTFExchange.TransactOpts, _newSafeFactory) +} + +// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. +// +// Solidity: function unpauseTrading() returns() +func (_CTFExchange *CTFExchangeTransactor) UnpauseTrading(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CTFExchange.contract.Transact(opts, "unpauseTrading") +} + +// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. +// +// Solidity: function unpauseTrading() returns() +func (_CTFExchange *CTFExchangeSession) UnpauseTrading() (*types.Transaction, error) { + return _CTFExchange.Contract.UnpauseTrading(&_CTFExchange.TransactOpts) +} + +// UnpauseTrading is a paid mutator transaction binding the contract method 0x456068d2. +// +// Solidity: function unpauseTrading() returns() +func (_CTFExchange *CTFExchangeTransactorSession) UnpauseTrading() (*types.Transaction, error) { + return _CTFExchange.Contract.UnpauseTrading(&_CTFExchange.TransactOpts) +} + +// CTFExchangeFeeChargedIterator is returned from FilterFeeCharged and is used to iterate over the raw logs and unpacked data for FeeCharged events raised by the CTFExchange contract. +type CTFExchangeFeeChargedIterator struct { + Event *CTFExchangeFeeCharged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeFeeChargedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeFeeCharged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeFeeCharged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeFeeChargedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeFeeChargedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeFeeCharged represents a FeeCharged event raised by the CTFExchange contract. +type CTFExchangeFeeCharged struct { + Receiver common.Address + TokenId *big.Int + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterFeeCharged is a free log retrieval operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. +// +// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) +func (_CTFExchange *CTFExchangeFilterer) FilterFeeCharged(opts *bind.FilterOpts, receiver []common.Address) (*CTFExchangeFeeChargedIterator, error) { + + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "FeeCharged", receiverRule) + if err != nil { + return nil, err + } + return &CTFExchangeFeeChargedIterator{contract: _CTFExchange.contract, event: "FeeCharged", logs: logs, sub: sub}, nil +} + +// WatchFeeCharged is a free log subscription operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. +// +// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) +func (_CTFExchange *CTFExchangeFilterer) WatchFeeCharged(opts *bind.WatchOpts, sink chan<- *CTFExchangeFeeCharged, receiver []common.Address) (event.Subscription, error) { + + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "FeeCharged", receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeFeeCharged) + if err := _CTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseFeeCharged is a log parse operation binding the contract event 0xacffcc86834d0f1a64b0d5a675798deed6ff0bcfc2231edd3480e7288dba7ff4. +// +// Solidity: event FeeCharged(address indexed receiver, uint256 tokenId, uint256 amount) +func (_CTFExchange *CTFExchangeFilterer) ParseFeeCharged(log types.Log) (*CTFExchangeFeeCharged, error) { + event := new(CTFExchangeFeeCharged) + if err := _CTFExchange.contract.UnpackLog(event, "FeeCharged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeNewAdminIterator is returned from FilterNewAdmin and is used to iterate over the raw logs and unpacked data for NewAdmin events raised by the CTFExchange contract. +type CTFExchangeNewAdminIterator struct { + Event *CTFExchangeNewAdmin // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeNewAdminIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeNewAdminIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeNewAdminIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeNewAdmin represents a NewAdmin event raised by the CTFExchange contract. +type CTFExchangeNewAdmin struct { + NewAdminAddress common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewAdmin is a free log retrieval operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. +// +// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) FilterNewAdmin(opts *bind.FilterOpts, newAdminAddress []common.Address, admin []common.Address) (*CTFExchangeNewAdminIterator, error) { + + var newAdminAddressRule []interface{} + for _, newAdminAddressItem := range newAdminAddress { + newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) + if err != nil { + return nil, err + } + return &CTFExchangeNewAdminIterator{contract: _CTFExchange.contract, event: "NewAdmin", logs: logs, sub: sub}, nil +} + +// WatchNewAdmin is a free log subscription operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. +// +// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) WatchNewAdmin(opts *bind.WatchOpts, sink chan<- *CTFExchangeNewAdmin, newAdminAddress []common.Address, admin []common.Address) (event.Subscription, error) { + + var newAdminAddressRule []interface{} + for _, newAdminAddressItem := range newAdminAddress { + newAdminAddressRule = append(newAdminAddressRule, newAdminAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "NewAdmin", newAdminAddressRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeNewAdmin) + if err := _CTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewAdmin is a log parse operation binding the contract event 0xf9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc. +// +// Solidity: event NewAdmin(address indexed newAdminAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) ParseNewAdmin(log types.Log) (*CTFExchangeNewAdmin, error) { + event := new(CTFExchangeNewAdmin) + if err := _CTFExchange.contract.UnpackLog(event, "NewAdmin", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeNewOperatorIterator is returned from FilterNewOperator and is used to iterate over the raw logs and unpacked data for NewOperator events raised by the CTFExchange contract. +type CTFExchangeNewOperatorIterator struct { + Event *CTFExchangeNewOperator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeNewOperatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeNewOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeNewOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeNewOperatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeNewOperatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeNewOperator represents a NewOperator event raised by the CTFExchange contract. +type CTFExchangeNewOperator struct { + NewOperatorAddress common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewOperator is a free log retrieval operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. +// +// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) FilterNewOperator(opts *bind.FilterOpts, newOperatorAddress []common.Address, admin []common.Address) (*CTFExchangeNewOperatorIterator, error) { + + var newOperatorAddressRule []interface{} + for _, newOperatorAddressItem := range newOperatorAddress { + newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) + if err != nil { + return nil, err + } + return &CTFExchangeNewOperatorIterator{contract: _CTFExchange.contract, event: "NewOperator", logs: logs, sub: sub}, nil +} + +// WatchNewOperator is a free log subscription operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. +// +// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) WatchNewOperator(opts *bind.WatchOpts, sink chan<- *CTFExchangeNewOperator, newOperatorAddress []common.Address, admin []common.Address) (event.Subscription, error) { + + var newOperatorAddressRule []interface{} + for _, newOperatorAddressItem := range newOperatorAddress { + newOperatorAddressRule = append(newOperatorAddressRule, newOperatorAddressItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "NewOperator", newOperatorAddressRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeNewOperator) + if err := _CTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewOperator is a log parse operation binding the contract event 0xf1e04d73c4304b5ff164f9d10c7473e2a1593b740674a6107975e2a7001c1e5c. +// +// Solidity: event NewOperator(address indexed newOperatorAddress, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) ParseNewOperator(log types.Log) (*CTFExchangeNewOperator, error) { + event := new(CTFExchangeNewOperator) + if err := _CTFExchange.contract.UnpackLog(event, "NewOperator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeOrderCancelledIterator is returned from FilterOrderCancelled and is used to iterate over the raw logs and unpacked data for OrderCancelled events raised by the CTFExchange contract. +type CTFExchangeOrderCancelledIterator struct { + Event *CTFExchangeOrderCancelled // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeOrderCancelledIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrderCancelled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrderCancelled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeOrderCancelledIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeOrderCancelledIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeOrderCancelled represents a OrderCancelled event raised by the CTFExchange contract. +type CTFExchangeOrderCancelled struct { + OrderHash [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOrderCancelled is a free log retrieval operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. +// +// Solidity: event OrderCancelled(bytes32 indexed orderHash) +func (_CTFExchange *CTFExchangeFilterer) FilterOrderCancelled(opts *bind.FilterOpts, orderHash [][32]byte) (*CTFExchangeOrderCancelledIterator, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "OrderCancelled", orderHashRule) + if err != nil { + return nil, err + } + return &CTFExchangeOrderCancelledIterator{contract: _CTFExchange.contract, event: "OrderCancelled", logs: logs, sub: sub}, nil +} + +// WatchOrderCancelled is a free log subscription operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. +// +// Solidity: event OrderCancelled(bytes32 indexed orderHash) +func (_CTFExchange *CTFExchangeFilterer) WatchOrderCancelled(opts *bind.WatchOpts, sink chan<- *CTFExchangeOrderCancelled, orderHash [][32]byte) (event.Subscription, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "OrderCancelled", orderHashRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeOrderCancelled) + if err := _CTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOrderCancelled is a log parse operation binding the contract event 0x5152abf959f6564662358c2e52b702259b78bac5ee7842a0f01937e670efcc7d. +// +// Solidity: event OrderCancelled(bytes32 indexed orderHash) +func (_CTFExchange *CTFExchangeFilterer) ParseOrderCancelled(log types.Log) (*CTFExchangeOrderCancelled, error) { + event := new(CTFExchangeOrderCancelled) + if err := _CTFExchange.contract.UnpackLog(event, "OrderCancelled", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeOrderFilledIterator is returned from FilterOrderFilled and is used to iterate over the raw logs and unpacked data for OrderFilled events raised by the CTFExchange contract. +type CTFExchangeOrderFilledIterator struct { + Event *CTFExchangeOrderFilled // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeOrderFilledIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrderFilled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrderFilled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeOrderFilledIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeOrderFilledIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeOrderFilled represents a OrderFilled event raised by the CTFExchange contract. +type CTFExchangeOrderFilled struct { + OrderHash [32]byte + Maker common.Address + Taker common.Address + MakerAssetId *big.Int + TakerAssetId *big.Int + MakerAmountFilled *big.Int + TakerAmountFilled *big.Int + Fee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOrderFilled is a free log retrieval operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. +// +// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) +func (_CTFExchange *CTFExchangeFilterer) FilterOrderFilled(opts *bind.FilterOpts, orderHash [][32]byte, maker []common.Address, taker []common.Address) (*CTFExchangeOrderFilledIterator, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + var makerRule []interface{} + for _, makerItem := range maker { + makerRule = append(makerRule, makerItem) + } + var takerRule []interface{} + for _, takerItem := range taker { + takerRule = append(takerRule, takerItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) + if err != nil { + return nil, err + } + return &CTFExchangeOrderFilledIterator{contract: _CTFExchange.contract, event: "OrderFilled", logs: logs, sub: sub}, nil +} + +// WatchOrderFilled is a free log subscription operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. +// +// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) +func (_CTFExchange *CTFExchangeFilterer) WatchOrderFilled(opts *bind.WatchOpts, sink chan<- *CTFExchangeOrderFilled, orderHash [][32]byte, maker []common.Address, taker []common.Address) (event.Subscription, error) { + + var orderHashRule []interface{} + for _, orderHashItem := range orderHash { + orderHashRule = append(orderHashRule, orderHashItem) + } + var makerRule []interface{} + for _, makerItem := range maker { + makerRule = append(makerRule, makerItem) + } + var takerRule []interface{} + for _, takerItem := range taker { + takerRule = append(takerRule, takerItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "OrderFilled", orderHashRule, makerRule, takerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeOrderFilled) + if err := _CTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOrderFilled is a log parse operation binding the contract event 0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6. +// +// Solidity: event OrderFilled(bytes32 indexed orderHash, address indexed maker, address indexed taker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled, uint256 fee) +func (_CTFExchange *CTFExchangeFilterer) ParseOrderFilled(log types.Log) (*CTFExchangeOrderFilled, error) { + event := new(CTFExchangeOrderFilled) + if err := _CTFExchange.contract.UnpackLog(event, "OrderFilled", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeOrdersMatchedIterator is returned from FilterOrdersMatched and is used to iterate over the raw logs and unpacked data for OrdersMatched events raised by the CTFExchange contract. +type CTFExchangeOrdersMatchedIterator struct { + Event *CTFExchangeOrdersMatched // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeOrdersMatchedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrdersMatched) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeOrdersMatched) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeOrdersMatchedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeOrdersMatchedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeOrdersMatched represents a OrdersMatched event raised by the CTFExchange contract. +type CTFExchangeOrdersMatched struct { + TakerOrderHash [32]byte + TakerOrderMaker common.Address + MakerAssetId *big.Int + TakerAssetId *big.Int + MakerAmountFilled *big.Int + TakerAmountFilled *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOrdersMatched is a free log retrieval operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. +// +// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) +func (_CTFExchange *CTFExchangeFilterer) FilterOrdersMatched(opts *bind.FilterOpts, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (*CTFExchangeOrdersMatchedIterator, error) { + + var takerOrderHashRule []interface{} + for _, takerOrderHashItem := range takerOrderHash { + takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) + } + var takerOrderMakerRule []interface{} + for _, takerOrderMakerItem := range takerOrderMaker { + takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) + if err != nil { + return nil, err + } + return &CTFExchangeOrdersMatchedIterator{contract: _CTFExchange.contract, event: "OrdersMatched", logs: logs, sub: sub}, nil +} + +// WatchOrdersMatched is a free log subscription operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. +// +// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) +func (_CTFExchange *CTFExchangeFilterer) WatchOrdersMatched(opts *bind.WatchOpts, sink chan<- *CTFExchangeOrdersMatched, takerOrderHash [][32]byte, takerOrderMaker []common.Address) (event.Subscription, error) { + + var takerOrderHashRule []interface{} + for _, takerOrderHashItem := range takerOrderHash { + takerOrderHashRule = append(takerOrderHashRule, takerOrderHashItem) + } + var takerOrderMakerRule []interface{} + for _, takerOrderMakerItem := range takerOrderMaker { + takerOrderMakerRule = append(takerOrderMakerRule, takerOrderMakerItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "OrdersMatched", takerOrderHashRule, takerOrderMakerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeOrdersMatched) + if err := _CTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOrdersMatched is a log parse operation binding the contract event 0x63bf4d16b7fa898ef4c4b2b6d90fd201e9c56313b65638af6088d149d2ce956c. +// +// Solidity: event OrdersMatched(bytes32 indexed takerOrderHash, address indexed takerOrderMaker, uint256 makerAssetId, uint256 takerAssetId, uint256 makerAmountFilled, uint256 takerAmountFilled) +func (_CTFExchange *CTFExchangeFilterer) ParseOrdersMatched(log types.Log) (*CTFExchangeOrdersMatched, error) { + event := new(CTFExchangeOrdersMatched) + if err := _CTFExchange.contract.UnpackLog(event, "OrdersMatched", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeProxyFactoryUpdatedIterator is returned from FilterProxyFactoryUpdated and is used to iterate over the raw logs and unpacked data for ProxyFactoryUpdated events raised by the CTFExchange contract. +type CTFExchangeProxyFactoryUpdatedIterator struct { + Event *CTFExchangeProxyFactoryUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeProxyFactoryUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeProxyFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeProxyFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeProxyFactoryUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeProxyFactoryUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeProxyFactoryUpdated represents a ProxyFactoryUpdated event raised by the CTFExchange contract. +type CTFExchangeProxyFactoryUpdated struct { + OldProxyFactory common.Address + NewProxyFactory common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterProxyFactoryUpdated is a free log retrieval operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. +// +// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) +func (_CTFExchange *CTFExchangeFilterer) FilterProxyFactoryUpdated(opts *bind.FilterOpts, oldProxyFactory []common.Address, newProxyFactory []common.Address) (*CTFExchangeProxyFactoryUpdatedIterator, error) { + + var oldProxyFactoryRule []interface{} + for _, oldProxyFactoryItem := range oldProxyFactory { + oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) + } + var newProxyFactoryRule []interface{} + for _, newProxyFactoryItem := range newProxyFactory { + newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) + if err != nil { + return nil, err + } + return &CTFExchangeProxyFactoryUpdatedIterator{contract: _CTFExchange.contract, event: "ProxyFactoryUpdated", logs: logs, sub: sub}, nil +} + +// WatchProxyFactoryUpdated is a free log subscription operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. +// +// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) +func (_CTFExchange *CTFExchangeFilterer) WatchProxyFactoryUpdated(opts *bind.WatchOpts, sink chan<- *CTFExchangeProxyFactoryUpdated, oldProxyFactory []common.Address, newProxyFactory []common.Address) (event.Subscription, error) { + + var oldProxyFactoryRule []interface{} + for _, oldProxyFactoryItem := range oldProxyFactory { + oldProxyFactoryRule = append(oldProxyFactoryRule, oldProxyFactoryItem) + } + var newProxyFactoryRule []interface{} + for _, newProxyFactoryItem := range newProxyFactory { + newProxyFactoryRule = append(newProxyFactoryRule, newProxyFactoryItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "ProxyFactoryUpdated", oldProxyFactoryRule, newProxyFactoryRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeProxyFactoryUpdated) + if err := _CTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseProxyFactoryUpdated is a log parse operation binding the contract event 0x3053c6252a932554235c173caffc1913604dba3a41cee89516f631c4a1a50a37. +// +// Solidity: event ProxyFactoryUpdated(address indexed oldProxyFactory, address indexed newProxyFactory) +func (_CTFExchange *CTFExchangeFilterer) ParseProxyFactoryUpdated(log types.Log) (*CTFExchangeProxyFactoryUpdated, error) { + event := new(CTFExchangeProxyFactoryUpdated) + if err := _CTFExchange.contract.UnpackLog(event, "ProxyFactoryUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeRemovedAdminIterator is returned from FilterRemovedAdmin and is used to iterate over the raw logs and unpacked data for RemovedAdmin events raised by the CTFExchange contract. +type CTFExchangeRemovedAdminIterator struct { + Event *CTFExchangeRemovedAdmin // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeRemovedAdminIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeRemovedAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeRemovedAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeRemovedAdminIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeRemovedAdminIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeRemovedAdmin represents a RemovedAdmin event raised by the CTFExchange contract. +type CTFExchangeRemovedAdmin struct { + RemovedAdmin common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemovedAdmin is a free log retrieval operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. +// +// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) FilterRemovedAdmin(opts *bind.FilterOpts, removedAdmin []common.Address, admin []common.Address) (*CTFExchangeRemovedAdminIterator, error) { + + var removedAdminRule []interface{} + for _, removedAdminItem := range removedAdmin { + removedAdminRule = append(removedAdminRule, removedAdminItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) + if err != nil { + return nil, err + } + return &CTFExchangeRemovedAdminIterator{contract: _CTFExchange.contract, event: "RemovedAdmin", logs: logs, sub: sub}, nil +} + +// WatchRemovedAdmin is a free log subscription operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. +// +// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) WatchRemovedAdmin(opts *bind.WatchOpts, sink chan<- *CTFExchangeRemovedAdmin, removedAdmin []common.Address, admin []common.Address) (event.Subscription, error) { + + var removedAdminRule []interface{} + for _, removedAdminItem := range removedAdmin { + removedAdminRule = append(removedAdminRule, removedAdminItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "RemovedAdmin", removedAdminRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeRemovedAdmin) + if err := _CTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemovedAdmin is a log parse operation binding the contract event 0x787a2e12f4a55b658b8f573c32432ee11a5e8b51677d1e1e937aaf6a0bb5776e. +// +// Solidity: event RemovedAdmin(address indexed removedAdmin, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) ParseRemovedAdmin(log types.Log) (*CTFExchangeRemovedAdmin, error) { + event := new(CTFExchangeRemovedAdmin) + if err := _CTFExchange.contract.UnpackLog(event, "RemovedAdmin", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeRemovedOperatorIterator is returned from FilterRemovedOperator and is used to iterate over the raw logs and unpacked data for RemovedOperator events raised by the CTFExchange contract. +type CTFExchangeRemovedOperatorIterator struct { + Event *CTFExchangeRemovedOperator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeRemovedOperatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeRemovedOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeRemovedOperator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeRemovedOperatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeRemovedOperatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeRemovedOperator represents a RemovedOperator event raised by the CTFExchange contract. +type CTFExchangeRemovedOperator struct { + RemovedOperator common.Address + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemovedOperator is a free log retrieval operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. +// +// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) FilterRemovedOperator(opts *bind.FilterOpts, removedOperator []common.Address, admin []common.Address) (*CTFExchangeRemovedOperatorIterator, error) { + + var removedOperatorRule []interface{} + for _, removedOperatorItem := range removedOperator { + removedOperatorRule = append(removedOperatorRule, removedOperatorItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) + if err != nil { + return nil, err + } + return &CTFExchangeRemovedOperatorIterator{contract: _CTFExchange.contract, event: "RemovedOperator", logs: logs, sub: sub}, nil +} + +// WatchRemovedOperator is a free log subscription operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. +// +// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) WatchRemovedOperator(opts *bind.WatchOpts, sink chan<- *CTFExchangeRemovedOperator, removedOperator []common.Address, admin []common.Address) (event.Subscription, error) { + + var removedOperatorRule []interface{} + for _, removedOperatorItem := range removedOperator { + removedOperatorRule = append(removedOperatorRule, removedOperatorItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "RemovedOperator", removedOperatorRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeRemovedOperator) + if err := _CTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemovedOperator is a log parse operation binding the contract event 0xf7262ed0443cc211121ceb1a80d69004f319245615a7488f951f1437fd91642c. +// +// Solidity: event RemovedOperator(address indexed removedOperator, address indexed admin) +func (_CTFExchange *CTFExchangeFilterer) ParseRemovedOperator(log types.Log) (*CTFExchangeRemovedOperator, error) { + event := new(CTFExchangeRemovedOperator) + if err := _CTFExchange.contract.UnpackLog(event, "RemovedOperator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeSafeFactoryUpdatedIterator is returned from FilterSafeFactoryUpdated and is used to iterate over the raw logs and unpacked data for SafeFactoryUpdated events raised by the CTFExchange contract. +type CTFExchangeSafeFactoryUpdatedIterator struct { + Event *CTFExchangeSafeFactoryUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeSafeFactoryUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeSafeFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeSafeFactoryUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeSafeFactoryUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeSafeFactoryUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeSafeFactoryUpdated represents a SafeFactoryUpdated event raised by the CTFExchange contract. +type CTFExchangeSafeFactoryUpdated struct { + OldSafeFactory common.Address + NewSafeFactory common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSafeFactoryUpdated is a free log retrieval operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. +// +// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) +func (_CTFExchange *CTFExchangeFilterer) FilterSafeFactoryUpdated(opts *bind.FilterOpts, oldSafeFactory []common.Address, newSafeFactory []common.Address) (*CTFExchangeSafeFactoryUpdatedIterator, error) { + + var oldSafeFactoryRule []interface{} + for _, oldSafeFactoryItem := range oldSafeFactory { + oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) + } + var newSafeFactoryRule []interface{} + for _, newSafeFactoryItem := range newSafeFactory { + newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) + if err != nil { + return nil, err + } + return &CTFExchangeSafeFactoryUpdatedIterator{contract: _CTFExchange.contract, event: "SafeFactoryUpdated", logs: logs, sub: sub}, nil +} + +// WatchSafeFactoryUpdated is a free log subscription operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. +// +// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) +func (_CTFExchange *CTFExchangeFilterer) WatchSafeFactoryUpdated(opts *bind.WatchOpts, sink chan<- *CTFExchangeSafeFactoryUpdated, oldSafeFactory []common.Address, newSafeFactory []common.Address) (event.Subscription, error) { + + var oldSafeFactoryRule []interface{} + for _, oldSafeFactoryItem := range oldSafeFactory { + oldSafeFactoryRule = append(oldSafeFactoryRule, oldSafeFactoryItem) + } + var newSafeFactoryRule []interface{} + for _, newSafeFactoryItem := range newSafeFactory { + newSafeFactoryRule = append(newSafeFactoryRule, newSafeFactoryItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "SafeFactoryUpdated", oldSafeFactoryRule, newSafeFactoryRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeSafeFactoryUpdated) + if err := _CTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSafeFactoryUpdated is a log parse operation binding the contract event 0x9726d7faf7429d6b059560dc858ed769377ccdf8b7541eabe12b22548719831f. +// +// Solidity: event SafeFactoryUpdated(address indexed oldSafeFactory, address indexed newSafeFactory) +func (_CTFExchange *CTFExchangeFilterer) ParseSafeFactoryUpdated(log types.Log) (*CTFExchangeSafeFactoryUpdated, error) { + event := new(CTFExchangeSafeFactoryUpdated) + if err := _CTFExchange.contract.UnpackLog(event, "SafeFactoryUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeTokenRegisteredIterator is returned from FilterTokenRegistered and is used to iterate over the raw logs and unpacked data for TokenRegistered events raised by the CTFExchange contract. +type CTFExchangeTokenRegisteredIterator struct { + Event *CTFExchangeTokenRegistered // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeTokenRegisteredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTokenRegistered) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTokenRegistered) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeTokenRegisteredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeTokenRegisteredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeTokenRegistered represents a TokenRegistered event raised by the CTFExchange contract. +type CTFExchangeTokenRegistered struct { + Token0 *big.Int + Token1 *big.Int + ConditionId [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTokenRegistered is a free log retrieval operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. +// +// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) +func (_CTFExchange *CTFExchangeFilterer) FilterTokenRegistered(opts *bind.FilterOpts, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (*CTFExchangeTokenRegisteredIterator, error) { + + var token0Rule []interface{} + for _, token0Item := range token0 { + token0Rule = append(token0Rule, token0Item) + } + var token1Rule []interface{} + for _, token1Item := range token1 { + token1Rule = append(token1Rule, token1Item) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) + if err != nil { + return nil, err + } + return &CTFExchangeTokenRegisteredIterator{contract: _CTFExchange.contract, event: "TokenRegistered", logs: logs, sub: sub}, nil +} + +// WatchTokenRegistered is a free log subscription operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. +// +// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) +func (_CTFExchange *CTFExchangeFilterer) WatchTokenRegistered(opts *bind.WatchOpts, sink chan<- *CTFExchangeTokenRegistered, token0 []*big.Int, token1 []*big.Int, conditionId [][32]byte) (event.Subscription, error) { + + var token0Rule []interface{} + for _, token0Item := range token0 { + token0Rule = append(token0Rule, token0Item) + } + var token1Rule []interface{} + for _, token1Item := range token1 { + token1Rule = append(token1Rule, token1Item) + } + var conditionIdRule []interface{} + for _, conditionIdItem := range conditionId { + conditionIdRule = append(conditionIdRule, conditionIdItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "TokenRegistered", token0Rule, token1Rule, conditionIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeTokenRegistered) + if err := _CTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTokenRegistered is a log parse operation binding the contract event 0xbc9a2432e8aeb48327246cddd6e872ef452812b4243c04e6bfb786a2cd8faf0d. +// +// Solidity: event TokenRegistered(uint256 indexed token0, uint256 indexed token1, bytes32 indexed conditionId) +func (_CTFExchange *CTFExchangeFilterer) ParseTokenRegistered(log types.Log) (*CTFExchangeTokenRegistered, error) { + event := new(CTFExchangeTokenRegistered) + if err := _CTFExchange.contract.UnpackLog(event, "TokenRegistered", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeTradingPausedIterator is returned from FilterTradingPaused and is used to iterate over the raw logs and unpacked data for TradingPaused events raised by the CTFExchange contract. +type CTFExchangeTradingPausedIterator struct { + Event *CTFExchangeTradingPaused // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeTradingPausedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTradingPaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTradingPaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeTradingPausedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeTradingPausedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeTradingPaused represents a TradingPaused event raised by the CTFExchange contract. +type CTFExchangeTradingPaused struct { + Pauser common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTradingPaused is a free log retrieval operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. +// +// Solidity: event TradingPaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) FilterTradingPaused(opts *bind.FilterOpts, pauser []common.Address) (*CTFExchangeTradingPausedIterator, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "TradingPaused", pauserRule) + if err != nil { + return nil, err + } + return &CTFExchangeTradingPausedIterator{contract: _CTFExchange.contract, event: "TradingPaused", logs: logs, sub: sub}, nil +} + +// WatchTradingPaused is a free log subscription operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. +// +// Solidity: event TradingPaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) WatchTradingPaused(opts *bind.WatchOpts, sink chan<- *CTFExchangeTradingPaused, pauser []common.Address) (event.Subscription, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "TradingPaused", pauserRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeTradingPaused) + if err := _CTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTradingPaused is a log parse operation binding the contract event 0x203c4bd3e526634f661575359ff30de3b0edaba6c2cb1eac60f730b6d2d9d536. +// +// Solidity: event TradingPaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) ParseTradingPaused(log types.Log) (*CTFExchangeTradingPaused, error) { + event := new(CTFExchangeTradingPaused) + if err := _CTFExchange.contract.UnpackLog(event, "TradingPaused", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// CTFExchangeTradingUnpausedIterator is returned from FilterTradingUnpaused and is used to iterate over the raw logs and unpacked data for TradingUnpaused events raised by the CTFExchange contract. +type CTFExchangeTradingUnpausedIterator struct { + Event *CTFExchangeTradingUnpaused // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *CTFExchangeTradingUnpausedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTradingUnpaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(CTFExchangeTradingUnpaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *CTFExchangeTradingUnpausedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *CTFExchangeTradingUnpausedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// CTFExchangeTradingUnpaused represents a TradingUnpaused event raised by the CTFExchange contract. +type CTFExchangeTradingUnpaused struct { + Pauser common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTradingUnpaused is a free log retrieval operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. +// +// Solidity: event TradingUnpaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) FilterTradingUnpaused(opts *bind.FilterOpts, pauser []common.Address) (*CTFExchangeTradingUnpausedIterator, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _CTFExchange.contract.FilterLogs(opts, "TradingUnpaused", pauserRule) + if err != nil { + return nil, err + } + return &CTFExchangeTradingUnpausedIterator{contract: _CTFExchange.contract, event: "TradingUnpaused", logs: logs, sub: sub}, nil +} + +// WatchTradingUnpaused is a free log subscription operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. +// +// Solidity: event TradingUnpaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) WatchTradingUnpaused(opts *bind.WatchOpts, sink chan<- *CTFExchangeTradingUnpaused, pauser []common.Address) (event.Subscription, error) { + + var pauserRule []interface{} + for _, pauserItem := range pauser { + pauserRule = append(pauserRule, pauserItem) + } + + logs, sub, err := _CTFExchange.contract.WatchLogs(opts, "TradingUnpaused", pauserRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(CTFExchangeTradingUnpaused) + if err := _CTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTradingUnpaused is a log parse operation binding the contract event 0xa1e8a54850dbd7f520bcc09f47bff152294b77b2081da545a7adf531b7ea283b. +// +// Solidity: event TradingUnpaused(address indexed pauser) +func (_CTFExchange *CTFExchangeFilterer) ParseTradingUnpaused(log types.Log) (*CTFExchangeTradingUnpaused, error) { + event := new(CTFExchangeTradingUnpaused) + if err := _CTFExchange.contract.UnpackLog(event, "TradingUnpaused", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} From 8eae8cc2874dd440a4ff90ef76787e9e2fd323c3 Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 17:43:48 +0800 Subject: [PATCH 10/19] fix: fix typo --- go.sum | 18 ------------------ .../contract/polymarket/worker.go | 2 +- 2 files changed, 1 insertion(+), 19 deletions(-) diff --git a/go.sum b/go.sum index 8faea3af..8d414501 100644 --- a/go.sum +++ b/go.sum @@ -25,8 +25,6 @@ github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo github.com/andybalholm/cascadia v1.2.0/go.mod h1:YCyR8vOZT9aZ1CHEd8ap0gMVm2aFgxBp0T0eFw1RUQY= github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= -github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= -github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA= github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= @@ -106,8 +104,6 @@ github.com/ethereum/go-ethereum v1.13.15 h1:U7sSGYGo4SPjP6iNIifNoyIAiNjrmQkz6EwQ github.com/ethereum/go-ethereum v1.13.15/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/ferranbt/fastssz v0.1.2 h1:Dky6dXlngF6Qjc+EfDipAkE83N5I5DE68bY6O0VLNPk= -github.com/ferranbt/fastssz v0.1.2/go.mod h1:X5UPrE2u1UJjxHA8X54u04SBwdAQjG2sFtWs39YxyWs= github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA= github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= @@ -203,8 +199,6 @@ github.com/grafana/pyroscope-go v1.1.2 h1:7vCfdORYQMCxIzI3NlYAs3FcBP760+gWuYWOyi github.com/grafana/pyroscope-go v1.1.2/go.mod h1:HSSmHo2KRn6FasBA4vK7BMiQqyQq8KSuBKvrhkXxYPU= github.com/grafana/pyroscope-go/godeltaprof v0.1.8 h1:iwOtYXeeVSAeYefJNaxDytgjKtUuKQbJqgAIjlnicKg= github.com/grafana/pyroscope-go/godeltaprof v0.1.8/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= -github.com/graph-gophers/graphql-go v1.3.0 h1:Eb9x/q6MFpCLz7jBCiP/WTxjSDrYLR1QY41SORZyNJ0= -github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I= github.com/hamba/avro v1.8.0 h1:eCVrLX7UYThA3R3yBZ+rpmafA5qTc3ZjpTz6gYJoVGU= @@ -232,12 +226,6 @@ github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= -github.com/influxdata/influxdb-client-go/v2 v2.13.0 h1:ioBbLmR5NMbAjP4UVA5r9b5xGjpABD7j65pI8kFphDM= -github.com/influxdata/influxdb-client-go/v2 v2.13.0/go.mod h1:k+spCbt9hcvqvUiz0sr5D8LolXHqAAOfPw9v/RIRHl4= -github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c h1:qSHzRbhzK8RdXOsAdfDgO49TtqC1oZ+acxPrkfTxcCs= -github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= -github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf h1:7JTmneyiNEwVBOHSjoMxiWAqB992atOeepeFYegn5RU= -github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= @@ -336,8 +324,6 @@ github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJm github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= -github.com/oapi-codegen/runtime v1.0.0 h1:P4rqFX5fMFWqRzY9M/3YF9+aPSPPB06IzP2P7oOxrWo= -github.com/oapi-codegen/runtime v1.0.0/go.mod h1:LmCUMQuPB4M/nLXilQXhHw+BLZdDb18B34OO356yJ/A= github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= @@ -359,16 +345,12 @@ github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQ github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss= github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8= -github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU= -github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/orlangure/gnomock v0.31.0 h1:dgjlQ8DYUPMyNwMZJuYBH+/GF+e7h3sloldPzIJF4k4= github.com/orlangure/gnomock v0.31.0/go.mod h1:RagxeYv3bKi+li9Lio2Faw5t6Mcy4akkeqXzkgAS3w0= github.com/ory/dockertest/v3 v3.10.0 h1:4K3z2VMe8Woe++invjaTB7VRyQXQy5UY+loujO4aNE4= github.com/ory/dockertest/v3 v3.10.0/go.mod h1:nr57ZbRWMqfsdGdFNLHz5jjNdDb7VVFnzAeW1n5N1Lg= github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= -github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM= -github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ= github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker.go b/internal/engine/worker/decentralized/contract/polymarket/worker.go index 052d8031..dfa6275b 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker.go @@ -31,7 +31,7 @@ type worker struct { ethereumClient ethereum.Client tokenClient token.Client ctfExchange *polymarket.CTFExchangeFilterer - //negRiskCTF *polymarket.NegRiskCTFExchangeFilterer + // negRiskCTF *polymarket.NegRiskCTFExchangeFilterer } func (w *worker) Name() string { From c9bea4bda13f8a34eddaabe1779360efea68fa60 Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 17:56:16 +0800 Subject: [PATCH 11/19] fix: fix one logical error in generating metadata of new actions --- .../decentralized/contract/polymarket/worker.go | 8 ++++---- .../contract/polymarket/worker_test.go | 14 +++++++------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker.go b/internal/engine/worker/decentralized/contract/polymarket/worker.go index dfa6275b..4130b32d 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker.go @@ -178,12 +178,12 @@ func (w *worker) buildMarketTradeAction(ctx context.Context, _ *source.Task, cha buyAction := &activityx.Action{ Type: typex.CollectibleTrade, Platform: w.Platform(), - From: maker.String(), - To: taker.String(), + From: taker.String(), + To: maker.String(), Metadata: metadata.CollectibleTrade{ Action: metadata.ActionCollectibleTradeBuy, - Token: *makerToken, - Cost: takerToken, + Token: *takerToken, + Cost: makerToken, }, } diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go index b3bb6f4d..d546eae5 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go @@ -38,7 +38,7 @@ func TestWorker_Polymarket(t *testing.T) { wantError require.ErrorAssertionFunc }{ { - name: "Test Prediction Offer Match Finalization (buy, sell actions)", + name: "Test Offer Match Finalization", arguments: struct { task *source.Task config *config.Module @@ -128,17 +128,17 @@ func TestWorker_Polymarket(t *testing.T) { Metadata: metadata.CollectibleTrade{ Action: metadata.ActionCollectibleTradeBuy, Token: metadata.Token{ - Name: "Polygon", - Symbol: "MATIC", - Decimals: 18, - Value: lo.ToPtr(lo.Must(decimal.NewFromString("79506400"))), - }, - Cost: &metadata.Token{ Address: lo.ToPtr("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"), ID: lo.ToPtr(lo.Must(decimal.NewFromString("8457663681790058947550769538996974245890751367516560139630487435494614626997"))), Value: lo.ToPtr(lo.Must(decimal.NewFromString("274160000"))), Standard: metadata.StandardERC1155, }, + Cost: &metadata.Token{ + Name: "Polygon", + Symbol: "MATIC", + Decimals: 18, + Value: lo.ToPtr(lo.Must(decimal.NewFromString("79506400"))), + }, }, }, { From 7c5da21e3a0947b888514abe39ea3f81e7e0aea9 Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 18:13:22 +0800 Subject: [PATCH 12/19] feat: add a test case for batch offer match finalizations --- .../contract/polymarket/worker_test.go | 190 +++++++++++++++++- 1 file changed, 189 insertions(+), 1 deletion(-) diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go index d546eae5..b7ab3aea 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go @@ -38,7 +38,7 @@ func TestWorker_Polymarket(t *testing.T) { wantError require.ErrorAssertionFunc }{ { - name: "Test Offer Match Finalization", + name: "Test One Offer Match Finalization(Generate Buy & Sell Actions)", arguments: struct { task *source.Task config *config.Module @@ -167,6 +167,194 @@ func TestWorker_Polymarket(t *testing.T) { }, wantError: require.NoError, }, + + { + name: "Test Batch Offer Match Finalization", + arguments: struct { + task *source.Task + config *config.Module + }{ + task: &source.Task{ + Network: network.Polygon, + ChainID: 137, + Header: ðereum.Header{ + Hash: common.HexToHash("0xb511b8794659ed5b89526356f7e6f001952fff7865685242fb377412374eb6a5"), + ParentHash: common.HexToHash("0x2d68e2d0777fc2bcb1008a67ff79ab69ab288ea4639145a96f27b3adffa3e7be"), + UncleHash: common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"), + Coinbase: common.HexToAddress("0xa8B52F02108AA5F4B675bDcC973760022D7C6020"), + Number: lo.Must(new(big.Int).SetString("61729697", 0)), + GasLimit: 30000000, + GasUsed: 22240185, + Timestamp: 1726134259, + BaseFee: lo.Must(new(big.Int).SetString("51", 0)), + Transactions: nil, + }, + Transaction: ðereum.Transaction{ + BlockHash: common.HexToHash("0xa475a7f70346c3cf1c5f5496fe89963da6cedbbd2cd7abe63922a60a60842669"), + From: common.HexToAddress("0x769598dc61E5fB3D0DB4Ee969B4a10EeF564de7A"), + Gas: 900000, + GasPrice: lo.Must(new(big.Int).SetString("106500000051", 10)), + Hash: common.HexToHash("0xa475a7f70346c3cf1c5f5496fe89963da6cedbbd2cd7abe63922a60a60842669"), + Input: hexutil.MustDecode("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"), + To: lo.ToPtr(common.HexToAddress("0x56C79347e95530c01A2FC76E732f9566dA16E113")), + Value: lo.Must(new(big.Int).SetString("0", 0)), + Type: 2, + ChainID: lo.Must(new(big.Int).SetString("137", 0)), + }, + Receipt: ðereum.Receipt{ + BlockHash: common.HexToHash("0xb511b8794659ed5b89526356f7e6f001952fff7865685242fb377412374eb6a5"), + BlockNumber: lo.Must(new(big.Int).SetString("61729697", 0)), + ContractAddress: nil, + CumulativeGasUsed: 1886167, + EffectiveGasPrice: hexutil.MustDecodeBig("0x18cbe50933"), + GasUsed: 360318, + + Logs: []*ethereum.Log{{ + Address: common.HexToAddress("0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E"), + Topics: []common.Hash{ + common.HexToHash("0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6"), + common.HexToHash("0x4dc37aace70bd18c7e9feefc60bc4c49bec9d8a438905a7b4025ed3743a17464"), + common.HexToHash("0x0000000000000000000000006b7ec4ba079c0a258435ea36025f6190cd424562"), + common.HexToHash("0x000000000000000000000000c2d59964a61981bf1d040e14bb365974f507c327"), + }, + Data: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000000000000000000001a1ad53feeb99f71ac2cb633db04714334493bbf2d6664a99f2a2f9af2ff7369000000000000000000000000000000000000000000000000000000000001335800000000000000000000000000000000000000000000000000000000012c23f00000000000000000000000000000000000000000000000000000000000000000"), + BlockNumber: lo.Must(new(big.Int).SetString("61729697", 0)), + TransactionHash: common.HexToHash("0xa475a7f70346c3cf1c5f5496fe89963da6cedbbd2cd7abe63922a60a60842669"), + Index: 74, + Removed: false, + }, { + Address: common.HexToAddress("0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E"), + Topics: []common.Hash{ + common.HexToHash("0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6"), + common.HexToHash("0x90480b747515144eb13d1b8da9add38b368830d94785cd64a8521843159ad458"), + common.HexToHash("0x000000000000000000000000c2d59964a61981bf1d040e14bb365974f507c327"), + common.HexToHash("0x0000000000000000000000004bfb41d5b3570defd03c39a9a4d8de6bd8b8982e"), + }, + Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000000000000000000000061ea30b65cd4a9399f92c53e91586575a6d8135943ef22bb4889b6b01a77086b00000000000000000000000000000000000000000000000000000000012af09800000000000000000000000000000000000000000000000000000000012c23f00000000000000000000000000000000000000000000000000000000000000000"), + BlockNumber: lo.Must(new(big.Int).SetString("61729697", 0)), + TransactionHash: common.HexToHash("0xa475a7f70346c3cf1c5f5496fe89963da6cedbbd2cd7abe63922a60a60842669"), + Index: 76, + Removed: false, + }}, + Status: 1, + TransactionHash: common.HexToHash("0xa475a7f70346c3cf1c5f5496fe89963da6cedbbd2cd7abe63922a60a60842669"), + TransactionIndex: 3, + }, + }, + config: &config.Module{ + Network: network.Polygon, + Endpoint: config.Endpoint{ + URL: endpoint.MustGet(network.Polygon), + }, + }, + }, + want: &activityx.Activity{ + + ID: "0xa475a7f70346c3cf1c5f5496fe89963da6cedbbd2cd7abe63922a60a60842669", + Network: network.Polygon, + Index: 3, + From: "0x769598dc61E5fB3D0DB4Ee969B4a10EeF564de7A", + To: "0x56C79347e95530c01A2FC76E732f9566dA16E113", + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + Fee: &activityx.Fee{ + Amount: lo.Must(decimal.NewFromString("38373867018376218")), + Decimal: 18, + }, + Calldata: &activityx.Calldata{ + FunctionHash: "0xd2539b37", + }, + Actions: []*activityx.Action{ + { + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + From: "0xc2D59964A61981bf1D040E14bB365974f507C327", + To: "0x6b7Ec4ba079c0a258435Ea36025f6190cD424562", + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeBuy, + Token: metadata.Token{ + Address: lo.ToPtr("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"), + ID: lo.ToPtr(lo.Must(decimal.NewFromString("11807543882438356730428584319959237816456493548031271396061607499515283075945"))), + Value: lo.ToPtr(decimal.NewFromInt(19670000)), + Standard: metadata.StandardERC1155, + }, + Cost: &metadata.Token{ + Value: lo.ToPtr(decimal.NewFromInt(78680)), + Name: "Polygon", + Symbol: "MATIC", + Decimals: 18, + }, + }, + }, + { + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + From: "0x6b7Ec4ba079c0a258435Ea36025f6190cD424562", + To: "0xc2D59964A61981bf1D040E14bB365974f507C327", + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeSell, + Token: metadata.Token{ + Address: lo.ToPtr("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"), + ID: lo.ToPtr(lo.Must(decimal.NewFromString("11807543882438356730428584319959237816456493548031271396061607499515283075945"))), + Value: lo.ToPtr(decimal.NewFromInt(19670000)), + Standard: metadata.StandardERC1155, + }, + Cost: &metadata.Token{ + Value: lo.ToPtr(decimal.NewFromInt(78680)), + Name: "Polygon", + Symbol: "MATIC", + Decimals: 18, + }, + }, + }, + { + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + From: "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E", + To: "0xc2D59964A61981bf1D040E14bB365974f507C327", + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeBuy, + Token: metadata.Token{ + Address: lo.ToPtr("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"), + ID: lo.ToPtr(lo.Must(decimal.NewFromString("44288124726046135483095464909806845540163757513494361566988300031502732167275"))), + Value: lo.ToPtr(decimal.NewFromInt(19670000)), + Standard: metadata.StandardERC1155, + }, + Cost: &metadata.Token{ + Value: lo.ToPtr(decimal.NewFromInt(19591320)), + Name: "Polygon", + Symbol: "MATIC", + Decimals: 18, + }, + }, + }, + { + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + From: "0xc2D59964A61981bf1D040E14bB365974f507C327", + To: "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E", + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeSell, + Token: metadata.Token{ + Address: lo.ToPtr("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"), + ID: lo.ToPtr(lo.Must(decimal.NewFromString("44288124726046135483095464909806845540163757513494361566988300031502732167275"))), + Value: lo.ToPtr(decimal.NewFromInt(19670000)), + Standard: metadata.StandardERC1155, + }, + Cost: &metadata.Token{ + Value: lo.ToPtr(decimal.NewFromInt(19591320)), + Name: "Polygon", + Symbol: "MATIC", + Decimals: 18, + }, + }, + }, + }, + Status: true, + Timestamp: 1726134259, + }, + wantError: require.NoError, + }, } for _, testcase := range testcases { From bd811b08aeb755d25d7082cfc129435b4666988d Mon Sep 17 00:00:00 2001 From: frank Date: Thu, 12 Sep 2024 19:53:29 +0800 Subject: [PATCH 13/19] fix: fix a typo in one Offer Match test case --- .../decentralized/contract/polymarket/worker_test.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go index b7ab3aea..8a646b4d 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go @@ -123,8 +123,8 @@ func TestWorker_Polymarket(t *testing.T) { { Type: typex.CollectibleTrade, Platform: workerx.PlatformPolymarket.String(), - From: "0xABf500a9b3481Ee143FDE5078df1A202Eb88A4A6", - To: "0x43eD7d1Bf7c703136971Ae5E64F6E7fEeA435535", + From: "0x43eD7d1Bf7c703136971Ae5E64F6E7fEeA435535", + To: "0xABf500a9b3481Ee143FDE5078df1A202Eb88A4A6", Metadata: metadata.CollectibleTrade{ Action: metadata.ActionCollectibleTradeBuy, Token: metadata.Token{ @@ -161,7 +161,8 @@ func TestWorker_Polymarket(t *testing.T) { Value: lo.ToPtr(lo.Must(decimal.NewFromString("79506400"))), }, }, - }}, + }, + }, Status: true, Timestamp: 1726122849, }, From ac9a47c4386de3c6971d7ff0190a6f20e75f1c97 Mon Sep 17 00:00:00 2001 From: frank Date: Fri, 13 Sep 2024 02:04:17 +0800 Subject: [PATCH 14/19] fix: addressed issues from PR review, such as modifying function structs for consistency --- go.mod | 2 +- go.sum | 723 ------------------ .../contract/polymarket/worker.go | 33 +- .../ethereum/contract/polymarket/contract.go | 2 +- 4 files changed, 18 insertions(+), 742 deletions(-) delete mode 100644 go.sum diff --git a/go.mod b/go.mod index 19f6a3e3..129af6f4 100644 --- a/go.mod +++ b/go.mod @@ -62,7 +62,7 @@ require ( github.com/mitchellh/mapstructure v1.5.0 github.com/redis/rueidis v1.0.45 github.com/redis/rueidis/rueidiscompat v1.0.45 - github.com/rss3-network/protocol-go v0.5.7 + github.com/rss3-network/protocol-go v0.5.8 github.com/spf13/afero v1.11.0 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 github.com/tidwall/sjson v1.2.5 diff --git a/go.sum b/go.sum deleted file mode 100644 index 8d414501..00000000 --- a/go.sum +++ /dev/null @@ -1,723 +0,0 @@ -dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= -dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= -filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= -filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= -github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0= -github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= -github.com/DataDog/zstd v1.5.0 h1:+K/VEwIAaPcHiMtQvpLD4lqW7f0Gk3xdYZmI1hD+CXo= -github.com/DataDog/zstd v1.5.0/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= -github.com/JohannesKaufmann/html-to-markdown v1.6.0 h1:04VXMiE50YYfCfLboJCLcgqF5x+rHJnb1ssNmqpLH/k= -github.com/JohannesKaufmann/html-to-markdown v1.6.0/go.mod h1:NUI78lGg/a7vpEJTz/0uOcYMaibytE4BUOQS8k78yPQ= -github.com/Khan/genqlient v0.7.0 h1:GZ1meyRnzcDTK48EjqB8t3bcfYvHArCUUvgOwpz1D4w= -github.com/Khan/genqlient v0.7.0/go.mod h1:HNyy3wZvuYwmW3Y7mkoQLZsa/R5n5yIRajS1kPBvSFM= -github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= -github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw= -github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= -github.com/PuerkitoBio/goquery v1.9.2 h1:4/wZksC3KgkQw7SQgkKotmKljk0M6V8TUvA8Wb4yPeE= -github.com/PuerkitoBio/goquery v1.9.2/go.mod h1:GHPCaP0ODyyxqcNoFGYlAprUFH81NuRPd0GX3Zu2Mvk= -github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= -github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= -github.com/adrianbrad/psqldocker v1.2.1 h1:bvsRmbotpA89ruqGGzzaAZUBtDaIk98gO+JMBNVSZlI= -github.com/adrianbrad/psqldocker v1.2.1/go.mod h1:LbCnIy60YO6IRJYrF1r+eafKUgU9UnkSFx0gT8UiaUs= -github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ= -github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= -github.com/andybalholm/cascadia v1.2.0/go.mod h1:YCyR8vOZT9aZ1CHEd8ap0gMVm2aFgxBp0T0eFw1RUQY= -github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= -github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= -github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA= -github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE= -github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= -github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= -github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= -github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= -github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U= -github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2 h1:KdUfX2zKommPRa+PD0sWZUyXe9w277ABlgELO7H04IM= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= -github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= -github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= -github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= -github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= -github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= -github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cockroachdb/errors v1.8.1 h1:A5+txlVZfOqFBDa4mGz2bUWSp0aHElvHX2bKkdbQu+Y= -github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac= -github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f h1:o/kfcElHqOiXqcou5a3rIlMc7oJbMQkeLk0VQJ7zgqY= -github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= -github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= -github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= -github.com/cockroachdb/redact v1.0.8 h1:8QG/764wK+vmEYoOlfobpe12EQcS81ukx/a4hdVMxNw= -github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= -github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 h1:IKgmqgMQlVJIZj19CdocBeSfSaiCbEBZGKODaixqtHM= -github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ= -github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= -github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= -github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= -github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= -github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= -github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= -github.com/containerd/continuity v0.4.3 h1:6HVkalIp+2u1ZLH1J/pYX2oBVXlJZvh1X1A7bEZ9Su8= -github.com/containerd/continuity v0.4.3/go.mod h1:F6PTNCKepoxEaXLQp3wDAjygEnImnZ/7o4JzpodfroQ= -github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= -github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= -github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4= -github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= -github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= -github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= -github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= -github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY= -github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= -github.com/creasty/defaults v1.8.0 h1:z27FJxCAa0JKt3utc0sCImAEb+spPucmKoOdLHvHYKk= -github.com/creasty/defaults v1.8.0/go.mod h1:iGzKe6pbEHnpMPtfDXZEr0NVxWnPTjb1bbDy08fPzYM= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/deckarep/golang-set/v2 v2.3.1 h1:vjmkvJt/IV27WXPyYQpAh4bRyWJc5Y435D17XQ9QU5A= -github.com/deckarep/golang-set/v2 v2.3.1/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= -github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y= -github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= -github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= -github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= -github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= -github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= -github.com/docker/cli v26.1.1+incompatible h1:bE1/uE2tCa08fMv+7ikLR/RDPoCqytwrLtkIkSzxLvw= -github.com/docker/cli v26.1.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= -github.com/docker/docker v26.1.3+incompatible h1:lLCzRbrVZrljpVNobJu1J2FHk8V0s4BawoZippkc+xo= -github.com/docker/docker v26.1.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= -github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c= -github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc= -github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= -github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= -github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= -github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= -github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= -github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= -github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= -github.com/ethereum/go-ethereum v1.13.15 h1:U7sSGYGo4SPjP6iNIifNoyIAiNjrmQkz6EwQG+/EZWo= -github.com/ethereum/go-ethereum v1.13.15/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= -github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= -github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA= -github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= -github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= -github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= -github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= -github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= -github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= -github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= -github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4= -github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= -github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= -github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= -github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= -github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= -github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= -github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= -github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= -github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= -github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= -github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= -github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= -github.com/go-playground/form/v4 v4.2.1 h1:HjdRDKO0fftVMU5epjPW2SOREcZ6/wLUzEobqUGJuPw= -github.com/go-playground/form/v4 v4.2.1/go.mod h1:q1a2BY+AQUUzhl6xA/6hBetay6dEIhMHjgvJiGo6K7U= -github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= -github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= -github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= -github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= -github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA= -github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM= -github.com/go-redis/redis v6.15.9+incompatible h1:K0pv1D7EQUjfyoMql+r/jZqCLizCGKFlFgcHWWmHQjg= -github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA= -github.com/go-redis/redis/v7 v7.4.1 h1:PASvf36gyUpr2zdOUS/9Zqc80GbM+9BDyiJSJDDOrTI= -github.com/go-redis/redis/v7 v7.4.1/go.mod h1:JDNMw23GTyLNC4GZu9njt15ctBQVn7xjRfnwdHj/Dcg= -github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI= -github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo= -github.com/go-redsync/redsync/v4 v4.13.0 h1:49X6GJfnbLGaIpBBREM/zA4uIMDXKAh1NDkvQ1EkZKA= -github.com/go-redsync/redsync/v4 v4.13.0/go.mod h1:HMW4Q224GZQz6x1Xc7040Yfgacukdzu7ifTDAKiyErQ= -github.com/go-shiori/dom v0.0.0-20210627111528-4e4722cd0d65 h1:zx4B0AiwqKDQq+AgqxWeHwbbLJQeidq20hgfP+aMNWI= -github.com/go-shiori/dom v0.0.0-20210627111528-4e4722cd0d65/go.mod h1:NPO1+buE6TYOWhUI98/hXLHHJhunIpXRuvDN4xjkCoE= -github.com/go-shiori/go-readability v0.0.0-20231029095239-6b97d5aba789 h1:G6wSuUyCoLB9jrUokipsmFuRi8aJozt3phw/g9Sl4Xs= -github.com/go-shiori/go-readability v0.0.0-20231029095239-6b97d5aba789/go.mod h1:2DpZlTJO/ycxp/vsc/C11oUyveStOgIXB88SYV1lncI= -github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y= -github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= -github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= -github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= -github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= -github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= -github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= -github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= -github.com/gogs/chardet v0.0.0-20191104214054-4b6791f73a28/go.mod h1:Pcatq5tYkCW2Q6yrR2VRHlbHpZ/R4/7qyL1TCF7vl14= -github.com/gogs/chardet v0.0.0-20211120154057-b7413eaefb8f h1:3BSP1Tbs2djlpprl7wCLuiqMaUh5SJkkzI2gDs+FgLs= -github.com/gogs/chardet v0.0.0-20211120154057-b7413eaefb8f/go.mod h1:Pcatq5tYkCW2Q6yrR2VRHlbHpZ/R4/7qyL1TCF7vl14= -github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= -github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= -github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= -github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= -github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= -github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= -github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= -github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= -github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= -github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= -github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= -github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/gomodule/redigo v1.8.9 h1:Sl3u+2BI/kk+VEatbj0scLdrFhjPmbxOc1myhDP41ws= -github.com/gomodule/redigo v1.8.9/go.mod h1:7ArFNvsTjH8GMMzB4uy1snslv2BwmginuMs06a1uzZE= -github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= -github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8 h1:FKHo8hFI3A+7w0aUQuYXQ+6EN5stWmeY/AZqtM8xk9k= -github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo= -github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= -github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= -github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= -github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= -github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= -github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/grafana/pyroscope-go v1.1.2 h1:7vCfdORYQMCxIzI3NlYAs3FcBP760+gWuYWOyiVyYx8= -github.com/grafana/pyroscope-go v1.1.2/go.mod h1:HSSmHo2KRn6FasBA4vK7BMiQqyQq8KSuBKvrhkXxYPU= -github.com/grafana/pyroscope-go/godeltaprof v0.1.8 h1:iwOtYXeeVSAeYefJNaxDytgjKtUuKQbJqgAIjlnicKg= -github.com/grafana/pyroscope-go/godeltaprof v0.1.8/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I= -github.com/hamba/avro v1.8.0 h1:eCVrLX7UYThA3R3yBZ+rpmafA5qTc3ZjpTz6gYJoVGU= -github.com/hamba/avro v1.8.0/go.mod h1:NiGUcrLLT+CKfGu5REWQtD9OVPPYUGMVFiC+DE0lQfY= -github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= -github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= -github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= -github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= -github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= -github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= -github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= -github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= -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/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4= -github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= -github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= -github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= -github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= -github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= -github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= -github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= -github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= -github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= -github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= -github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= -github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= -github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= -github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= -github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 h1:L0QtFUgDarD7Fpv9jeVMgy/+Ec0mtnmYuImjTz6dtDA= -github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= -github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY= -github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw= -github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= -github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= -github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= -github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= -github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= -github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= -github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= -github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= -github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= -github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= -github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= -github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= -github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg= -github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= -github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/labstack/echo/v4 v4.12.0 h1:IKpw49IMryVB2p1a4dzwlhP1O2Tf2E0Ir/450lH+kI0= -github.com/labstack/echo/v4 v4.12.0/go.mod h1:UP9Cr2DJXbOK3Kr9ONYzNowSh7HP0aG0ShAyycHSJvM= -github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0= -github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU= -github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= -github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= -github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= -github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= -github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= -github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= -github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= -github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= -github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ= -github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= -github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= -github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= -github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= -github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY= -github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg= -github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= -github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= -github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= -github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= -github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= -github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= -github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= -github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= -github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= -github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= -github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0= -github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y= -github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= -github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= -github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= -github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= -github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= -github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE= -github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI= -github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0= -github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4= -github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g= -github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk= -github.com/multiformats/go-multicodec v0.9.0 h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg= -github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k= -github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U= -github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM= -github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8= -github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU= -github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= -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/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= -github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= -github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= -github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= -github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= -github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= -github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= -github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= -github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= -github.com/onsi/ginkgo/v2 v2.20.1 h1:YlVIbqct+ZmnEph770q9Q7NVAz4wwIiVNahee6JyUzo= -github.com/onsi/ginkgo/v2 v2.20.1/go.mod h1:lG9ey2Z29hR41WMVthyJBGUBcBhGOtoPF2VFMvBXFCI= -github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= -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.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k= -github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY= -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.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug= -github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= -github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss= -github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8= -github.com/orlangure/gnomock v0.31.0 h1:dgjlQ8DYUPMyNwMZJuYBH+/GF+e7h3sloldPzIJF4k4= -github.com/orlangure/gnomock v0.31.0/go.mod h1:RagxeYv3bKi+li9Lio2Faw5t6Mcy4akkeqXzkgAS3w0= -github.com/ory/dockertest/v3 v3.10.0 h1:4K3z2VMe8Woe++invjaTB7VRyQXQy5UY+loujO4aNE4= -github.com/ory/dockertest/v3 v3.10.0/go.mod h1:nr57ZbRWMqfsdGdFNLHz5jjNdDb7VVFnzAeW1n5N1Lg= -github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= -github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= -github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ= -github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= -github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pressly/goose/v3 v3.22.0 h1:wd/7kNiPTuNAztWun7iaB98DrhulbWPrzMAaw2DEZNw= -github.com/pressly/goose/v3 v3.22.0/go.mod h1:yJM3qwSj2pp7aAaCvso096sguezamNb2OBgxCnh/EYg= -github.com/prometheus/client_golang v1.20.3 h1:oPksm4K8B+Vt35tUhw6GbSNSgVlVSBH0qELP/7u83l4= -github.com/prometheus/client_golang v1.20.3/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= -github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= -github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= -github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc= -github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8= -github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= -github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= -github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8= -github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= -github.com/redis/rueidis v1.0.45 h1:j7hfcqfLLIqgTK3IkxBhXdeJcP34t3XLXvorDLqXfgM= -github.com/redis/rueidis v1.0.45/go.mod h1:by+34b0cFXndxtYmPAHpoTHO5NkosDlBvhexoTURIxM= -github.com/redis/rueidis/mock v1.0.45 h1:r2LRiwOtFib8+NAuVxNmcdxL7IMUk3as9IGPzx2v5tA= -github.com/redis/rueidis/mock v1.0.45/go.mod h1:bjpk7ox5jwue03L8NpjgPBE91tLkm9Amla+XFYhaezc= -github.com/redis/rueidis/rueidiscompat v1.0.45 h1:G+3HIaETgtwr6aL6BOTFCa2DfpPDhxqcoiDn8cvd5Ps= -github.com/redis/rueidis/rueidiscompat v1.0.45/go.mod h1:JMw3cktmwNqsSl2npjcxrOfLa1L3rmj1Ox5aPHiDjOU= -github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= -github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= -github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= -github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs= -github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro= -github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= -github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= -github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= -github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= -github.com/rss3-network/protocol-go v0.5.7 h1:EpZ/WiQzSMpUmvf0dWrZb+o0H+ntfG6/IW5NNoPx+PA= -github.com/rss3-network/protocol-go v0.5.7/go.mod h1:npcyduWt86uVbIi77xQaYk8eqltI9XNjk1FMGpjyIq0= -github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww= -github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= -github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= -github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= -github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= -github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= -github.com/samber/lo v1.47.0 h1:z7RynLwP5nbyRscyvcD043DWYoOcYRv3mV8lBeqOCLc= -github.com/samber/lo v1.47.0/go.mod h1:RmDH9Ct32Qy3gduHQuKJ3gW1fMHAnE/fAzQuf6He5cU= -github.com/sebdah/goldie/v2 v2.5.3 h1:9ES/mNN+HNUbNWpVAlrzuZ7jE+Nrczbj8uFRjM7624Y= -github.com/sebdah/goldie/v2 v2.5.3/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI= -github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= -github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8= -github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I= -github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE= -github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas= -github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= -github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= -github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= -github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= -github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= -github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= -github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= -github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= -github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= -github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= -github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= -github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0= -github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= -github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM= -github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y= -github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= -github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI= -github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg= -github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= -github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203 h1:QVqDTf3h2WHt08YuiTGPZLls0Wq99X9bWd0Q5ZSBesM= -github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203/go.mod h1:oqN97ltKNihBbwlX8dLpwxCl3+HnXKV/R0e+sRLd9C8= -github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= -github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= -github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= -github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= -github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= -github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= -github.com/tdewolff/minify/v2 v2.20.37 h1:Q97cx4STXCh1dlWDlNHZniE8BJ2EBL0+2b0n92BJQhw= -github.com/tdewolff/minify/v2 v2.20.37/go.mod h1:L1VYef/jwKw6Wwyk5A+T0mBjjn3mMPgmjjA688RNsxU= -github.com/tdewolff/parse/v2 v2.7.15 h1:hysDXtdGZIRF5UZXwpfn3ZWRbm+ru4l53/ajBRGpCTw= -github.com/tdewolff/parse/v2 v2.7.15/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA= -github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE= -github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739 h1:IkjBCtQOOjIn03u/dMQK9g+Iw9ewps4mCl1nB8Sscbo= -github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8= -github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= -github.com/tidwall/gjson v1.17.3 h1:bwWLZU7icoKRG+C+0PNwIKC6FCJO/Q3p2pZvuP0jN94= -github.com/tidwall/gjson v1.17.3/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= -github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= -github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= -github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= -github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= -github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= -github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= -github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= -github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= -github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= -github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= -github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= -github.com/twmb/franz-go v1.17.1 h1:0LwPsbbJeJ9R91DPUHSEd4su82WJWcTY1Zzbgbg4CeQ= -github.com/twmb/franz-go v1.17.1/go.mod h1:NreRdJ2F7dziDY/m6VyspWd6sNxHKXdMZI42UfQ3GXM= -github.com/twmb/franz-go/pkg/kadm v1.13.0 h1:bJq4C2ZikUE2jh/wl9MtMTQ/kpmnBgVFh8XMQBEC+60= -github.com/twmb/franz-go/pkg/kadm v1.13.0/go.mod h1:VMvpfjz/szpH9WB+vGM+rteTzVv0djyHFimci9qm2C0= -github.com/twmb/franz-go/pkg/kmsg v1.8.0 h1:lAQB9Z3aMrIP9qF9288XcFf/ccaSxEitNA1CDTEIeTA= -github.com/twmb/franz-go/pkg/kmsg v1.8.0/go.mod h1:HzYEb8G3uu5XevZbtU0dVbkphaKTHk0X68N5ka4q6mU= -github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= -github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= -github.com/urfave/cli v1.22.1 h1:+mkCCcOFKPnCmVYVcURKps1Xe+3zP90gSYGNfRkjoIY= -github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs= -github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= -github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo= -github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= -github.com/vektah/gqlparser/v2 v2.5.11 h1:JJxLtXIoN7+3x6MBdtIP59TP1RANnY7pXOaDnADQSf8= -github.com/vektah/gqlparser/v2 v2.5.11/go.mod h1:1rCcfwB2ekJofmluGWXMSEnPMZgbxzwj6FaZ/4OT8Cc= -github.com/vincent-petithory/dataurl v1.0.0 h1:cXw+kPto8NLuJtlMsI152irrVw9fRDX8AbShPRpg2CI= -github.com/vincent-petithory/dataurl v1.0.0/go.mod h1:FHafX5vmDzyP+1CQATJn7WFKc9CvnvxyvZy6I1MrG/U= -github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= -github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo= -github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= -github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0= -github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= -github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= -github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= -github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= -github.com/yuin/goldmark v1.7.1 h1:3bajkSilaCbjdKVsKdZjZCLBNPL9pYzrCakKaf4U49U= -github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E= -github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw= -github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.50.0 h1:cEPbyTSEHlQR89XVlyo78gqluF8Y3oMeBkXGWzQsfXY= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.50.0/go.mod h1:DKdbWcT4GH1D0Y3Sqt/PFXt2naRKDWtU+eE6oLdFNA8= -go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw= -go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0 h1:dIIDULZJpgdiHz5tXrTgKIMLkus6jEFa7x5SOKcyR7E= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0/go.mod h1:jlRVBe7+Z1wyxFSUs48L6OBQZ5JwH2Hg/Vbl+t9rAgI= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.29.0 h1:JAv0Jwtl01UFiyWZEMiJZBiTlv5A50zNs8lsthXqIio= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.29.0/go.mod h1:QNKLmUEAq2QUbPQUfvw4fmv0bgbK7UlOSFCnXyfvSNc= -go.opentelemetry.io/otel/exporters/prometheus v0.51.0 h1:G7uexXb/K3T+T9fNLCCKncweEtNEBMTO+46hKX5EdKw= -go.opentelemetry.io/otel/exporters/prometheus v0.51.0/go.mod h1:v0mFe5Kk7woIh938mrZBJBmENYquyA0IICrlYm4Y0t4= -go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.29.0 h1:X3ZjNp36/WlkSYx0ul2jw4PtbNEDDeLskw3VPsrpYM0= -go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.29.0/go.mod h1:2uL/xnOXh0CHOBFCWXz5u1A4GXLiW+0IQIzVbeOEQ0U= -go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc= -go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8= -go.opentelemetry.io/otel/sdk v1.29.0 h1:vkqKjk7gwhS8VaWb0POZKmIEDimRCMsopNYnriHyryo= -go.opentelemetry.io/otel/sdk v1.29.0/go.mod h1:pM8Dx5WKnvxLCb+8lG1PRNIDxu9g9b9g59Qr7hfAAok= -go.opentelemetry.io/otel/sdk/metric v1.29.0 h1:K2CfmJohnRgvZ9UAj2/FhIf/okdWcNdBwe1m8xFXiSY= -go.opentelemetry.io/otel/sdk/metric v1.29.0/go.mod h1:6zZLdCl2fkauYoZIOn/soQIDSWFmNSRcICarHfuhNJQ= -go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4= -go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ= -go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0= -go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8= -go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= -go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= -go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= -go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= -go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= -go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= -go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= -go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= -go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= -go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= -go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= -golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M= -golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= -golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= -golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= -golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= -golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= -golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.0.0-20210505214959-0714010a04ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= -golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= -golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= -golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8= -golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= -golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo= -golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0= -golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= -golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= -golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= -golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= -golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= -golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= -golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk= -golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224= -golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= -golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= -golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= -golang.org/x/tools v0.24.0 h1:J1shsA93PJUEVaUSaay7UXAyE8aimq3GW0pjlolpa24= -golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd h1:BBOTEWLuuEGQy9n1y9MhVJ9Qt0BDu21X8qZs71/uPZo= -google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd/go.mod h1:fO8wJzT2zbQbAjbIoos1285VfEIYKDDY+Dt+WpTkh6g= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd h1:6TEm2ZxXoQmFWFlt1vNxvVOa1Q0dXFQD1m/rYjXmS0E= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= -google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc= -google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ= -google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= -google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= -google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= -google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= -google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= -google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= -google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= -gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= -gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8= -gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= -gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= -gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= -gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gorm.io/driver/postgres v1.5.9 h1:DkegyItji119OlcaLjqN11kHoUgZ/j13E0jkJZgD6A8= -gorm.io/driver/postgres v1.5.9/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI= -gorm.io/gorm v1.23.6/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk= -gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg= -gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= -gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo= -gotest.tools/v3 v3.3.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= -lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI= -lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k= -modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI= -modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4= -modernc.org/libc v1.55.3 h1:AzcW1mhlPNrRtjS5sS+eW2ISCgSOLLNyFzRh/V3Qj/U= -modernc.org/libc v1.55.3/go.mod h1:qFXepLhz+JjFThQ4kzwzOjA/y/artDeg+pcYnY+Q83w= -modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= -modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= -modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E= -modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU= -modernc.org/sqlite v1.32.0 h1:6BM4uGza7bWypsw4fdLRsLxut6bHe4c58VeqjRgST8s= -modernc.org/sqlite v1.32.0/go.mod h1:UqoylwmTb9F+IqXERT8bW9zzOWN8qwAIcLdzeBZs4hA= -modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA= -modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0= -modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= -modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= -moul.io/zapgorm2 v1.3.0 h1:+CzUTMIcnafd0d/BvBce8T4uPn6DQnpIrz64cyixlkk= -moul.io/zapgorm2 v1.3.0/go.mod h1:nPVy6U9goFKHR4s+zfSo1xVFaoU7Qgd5DoCdOfzoCqs= -rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= -rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker.go b/internal/engine/worker/decentralized/contract/polymarket/worker.go index 4130b32d..dbc4fb4d 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker.go @@ -31,7 +31,6 @@ type worker struct { ethereumClient ethereum.Client tokenClient token.Client ctfExchange *polymarket.CTFExchangeFilterer - // negRiskCTF *polymarket.NegRiskCTFExchangeFilterer } func (w *worker) Name() string { @@ -83,37 +82,37 @@ func (w *worker) Transform(ctx context.Context, task engine.Task) (*activityx.Ac return nil, fmt.Errorf("build activity: %w", err) } - activity.Type = typex.CollectibleTrade - activity.Actions = w.transformOrderTransaction(ctx, polygonTask) - - return activity, nil -} - -func (w *worker) transformOrderTransaction(ctx context.Context, polygonTask *source.Task) (actions []*activityx.Action) { for _, log := range polygonTask.Receipt.Logs { if len(log.Topics) == 0 { continue } var ( - buffer []*activityx.Action - err error + actions []*activityx.Action + err error ) - if !w.matchOrderFinalizedLog(polygonTask, log) { + switch { + + case w.matchOrderFinalizedLog(polygonTask, log): + actions, err = w.transformOrderFinalizedLog(ctx, polygonTask, log) + + default: + zap.L().Warn("unsupported log", zap.String("task", polygonTask.ID()), zap.Uint("topic.index", log.Index)) continue } - buffer, err = w.transformOrderFinalizedLog(ctx, polygonTask, log) if err != nil { zap.L().Warn("handle polymarket order transaction", zap.Error(err), zap.String("worker", w.Name()), zap.String("task", polygonTask.ID())) - continue - } - actions = append(actions, buffer...) + return nil, err + } + activity.Actions = append(activity.Actions, actions...) } - return actions + activity.Type = typex.CollectibleTrade + + return activity, nil } func (w *worker) matchOrderFinalizedLog(_ *source.Task, log *ethereum.Log) bool { @@ -206,7 +205,7 @@ func (w *worker) buildMarketTradeAction(ctx context.Context, _ *source.Task, cha func NewWorker(config *config.Module) (engine.Worker, error) { instance := worker{ ctfExchange: lo.Must(polymarket.NewCTFExchangeFilterer(ethereum.AddressGenesis, nil)), - //negRiskCTF: lo.Must(polymarket.NewNegRiskCTFExchangeFilterer(ethereum.AddressGenesis, nil)), + // negRiskCTF: lo.Must(polymarket.NewNegRiskCTFExchangeFilterer(ethereum.AddressGenesis, nil)), } var err error diff --git a/provider/ethereum/contract/polymarket/contract.go b/provider/ethereum/contract/polymarket/contract.go index fea1d8de..fe5a296e 100644 --- a/provider/ethereum/contract/polymarket/contract.go +++ b/provider/ethereum/contract/polymarket/contract.go @@ -10,7 +10,7 @@ import ( //go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/CTFExchange.abi --pkg polymarket --type CTFExchange --out contract_ctf_exchange.go // Neg Risk CTF Exchange // https://polygonscan.com/address/0xc5d563a36ae78145c45a50134d48a1215220f80a -// go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/NegRiskCTFExchange.abi --pkg polymarket --type NegRiskCTFExchange --out contract_neg_risk_ctf_exchange.go +//go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/NegRiskCTFExchange.abi --pkg polymarket --type NegRiskCTFExchange --out contract_neg_risk_ctf_exchange.go // Condition Tokens // https://polygonscan.com/address/0x4D97DCd97eC945f40cF65F87097ACe5EA0476045 //go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/ConditionTokens.abi --pkg polymarket --type ConditionTokens --out contract_condition_tokens.go From dd97a52bb2f7c38819099f633375e254d659a38b Mon Sep 17 00:00:00 2001 From: frank Date: Fri, 13 Sep 2024 02:05:11 +0800 Subject: [PATCH 15/19] fix: add network config params for polymarket --- .../engine/worker/decentralized/contract/polymarket/worker.go | 2 +- internal/node/component/info/network_config.go | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker.go b/internal/engine/worker/decentralized/contract/polymarket/worker.go index dbc4fb4d..2fa3448c 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker.go @@ -93,7 +93,6 @@ func (w *worker) Transform(ctx context.Context, task engine.Task) (*activityx.Ac ) switch { - case w.matchOrderFinalizedLog(polygonTask, log): actions, err = w.transformOrderFinalizedLog(ctx, polygonTask, log) @@ -107,6 +106,7 @@ func (w *worker) Transform(ctx context.Context, task engine.Task) (*activityx.Ac return nil, err } + activity.Actions = append(activity.Actions, actions...) } diff --git a/internal/node/component/info/network_config.go b/internal/node/component/info/network_config.go index 60e5e2c3..3cd9597c 100644 --- a/internal/node/component/info/network_config.go +++ b/internal/node/component/info/network_config.go @@ -264,6 +264,7 @@ var NetworkToWorkersMap = map[network.Network][]worker.Worker{ decentralized.Highlight, decentralized.IQWiki, decentralized.Lens, + decentralized.Polymarket, decentralized.Stargate, }, network.Crossbell: { @@ -353,6 +354,7 @@ var WorkerToConfigMap = map[network.Source]map[worker.Worker]workerConfig{ decentralized.OpenSea: defaultWorkerConfig(decentralized.OpenSea, network.EthereumSource, nil), decentralized.Optimism: defaultWorkerConfig(decentralized.Optimism, network.EthereumSource, nil), decentralized.Paraswap: defaultWorkerConfig(decentralized.Paraswap, network.EthereumSource, nil), + decentralized.Polymarket: defaultWorkerConfig(decentralized.Polymarket, network.EthereumSource, nil), decentralized.RSS3: defaultWorkerConfig(decentralized.RSS3, network.EthereumSource, nil), decentralized.SAVM: defaultWorkerConfig(decentralized.SAVM, network.EthereumSource, nil), decentralized.Stargate: defaultWorkerConfig(decentralized.Stargate, network.EthereumSource, nil), From 8c9febc6de400b84efb1e53869ad92403b3fb71d Mon Sep 17 00:00:00 2001 From: frank Date: Fri, 13 Sep 2024 02:07:57 +0800 Subject: [PATCH 16/19] fix: add go.sum --- go.sum | 723 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 723 insertions(+) create mode 100644 go.sum diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..e87c4764 --- /dev/null +++ b/go.sum @@ -0,0 +1,723 @@ +dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= +dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= +filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= +github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0= +github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/DataDog/zstd v1.5.0 h1:+K/VEwIAaPcHiMtQvpLD4lqW7f0Gk3xdYZmI1hD+CXo= +github.com/DataDog/zstd v1.5.0/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= +github.com/JohannesKaufmann/html-to-markdown v1.6.0 h1:04VXMiE50YYfCfLboJCLcgqF5x+rHJnb1ssNmqpLH/k= +github.com/JohannesKaufmann/html-to-markdown v1.6.0/go.mod h1:NUI78lGg/a7vpEJTz/0uOcYMaibytE4BUOQS8k78yPQ= +github.com/Khan/genqlient v0.7.0 h1:GZ1meyRnzcDTK48EjqB8t3bcfYvHArCUUvgOwpz1D4w= +github.com/Khan/genqlient v0.7.0/go.mod h1:HNyy3wZvuYwmW3Y7mkoQLZsa/R5n5yIRajS1kPBvSFM= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw= +github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= +github.com/PuerkitoBio/goquery v1.9.2 h1:4/wZksC3KgkQw7SQgkKotmKljk0M6V8TUvA8Wb4yPeE= +github.com/PuerkitoBio/goquery v1.9.2/go.mod h1:GHPCaP0ODyyxqcNoFGYlAprUFH81NuRPd0GX3Zu2Mvk= +github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= +github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= +github.com/adrianbrad/psqldocker v1.2.1 h1:bvsRmbotpA89ruqGGzzaAZUBtDaIk98gO+JMBNVSZlI= +github.com/adrianbrad/psqldocker v1.2.1/go.mod h1:LbCnIy60YO6IRJYrF1r+eafKUgU9UnkSFx0gT8UiaUs= +github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ= +github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= +github.com/andybalholm/cascadia v1.2.0/go.mod h1:YCyR8vOZT9aZ1CHEd8ap0gMVm2aFgxBp0T0eFw1RUQY= +github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= +github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= +github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA= +github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE= +github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= +github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U= +github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2 h1:KdUfX2zKommPRa+PD0sWZUyXe9w277ABlgELO7H04IM= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= +github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= +github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cockroachdb/errors v1.8.1 h1:A5+txlVZfOqFBDa4mGz2bUWSp0aHElvHX2bKkdbQu+Y= +github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac= +github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f h1:o/kfcElHqOiXqcou5a3rIlMc7oJbMQkeLk0VQJ7zgqY= +github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= +github.com/cockroachdb/redact v1.0.8 h1:8QG/764wK+vmEYoOlfobpe12EQcS81ukx/a4hdVMxNw= +github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 h1:IKgmqgMQlVJIZj19CdocBeSfSaiCbEBZGKODaixqtHM= +github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= +github.com/containerd/continuity v0.4.3 h1:6HVkalIp+2u1ZLH1J/pYX2oBVXlJZvh1X1A7bEZ9Su8= +github.com/containerd/continuity v0.4.3/go.mod h1:F6PTNCKepoxEaXLQp3wDAjygEnImnZ/7o4JzpodfroQ= +github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= +github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= +github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4= +github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= +github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY= +github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= +github.com/creasty/defaults v1.8.0 h1:z27FJxCAa0JKt3utc0sCImAEb+spPucmKoOdLHvHYKk= +github.com/creasty/defaults v1.8.0/go.mod h1:iGzKe6pbEHnpMPtfDXZEr0NVxWnPTjb1bbDy08fPzYM= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/deckarep/golang-set/v2 v2.3.1 h1:vjmkvJt/IV27WXPyYQpAh4bRyWJc5Y435D17XQ9QU5A= +github.com/deckarep/golang-set/v2 v2.3.1/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y= +github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= +github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= +github.com/docker/cli v26.1.1+incompatible h1:bE1/uE2tCa08fMv+7ikLR/RDPoCqytwrLtkIkSzxLvw= +github.com/docker/cli v26.1.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= +github.com/docker/docker v26.1.3+incompatible h1:lLCzRbrVZrljpVNobJu1J2FHk8V0s4BawoZippkc+xo= +github.com/docker/docker v26.1.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c= +github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc= +github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= +github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= +github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= +github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= +github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.13.15 h1:U7sSGYGo4SPjP6iNIifNoyIAiNjrmQkz6EwQG+/EZWo= +github.com/ethereum/go-ethereum v1.13.15/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA= +github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= +github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4= +github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= +github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/form/v4 v4.2.1 h1:HjdRDKO0fftVMU5epjPW2SOREcZ6/wLUzEobqUGJuPw= +github.com/go-playground/form/v4 v4.2.1/go.mod h1:q1a2BY+AQUUzhl6xA/6hBetay6dEIhMHjgvJiGo6K7U= +github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= +github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= +github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= +github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= +github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA= +github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM= +github.com/go-redis/redis v6.15.9+incompatible h1:K0pv1D7EQUjfyoMql+r/jZqCLizCGKFlFgcHWWmHQjg= +github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA= +github.com/go-redis/redis/v7 v7.4.1 h1:PASvf36gyUpr2zdOUS/9Zqc80GbM+9BDyiJSJDDOrTI= +github.com/go-redis/redis/v7 v7.4.1/go.mod h1:JDNMw23GTyLNC4GZu9njt15ctBQVn7xjRfnwdHj/Dcg= +github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI= +github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo= +github.com/go-redsync/redsync/v4 v4.13.0 h1:49X6GJfnbLGaIpBBREM/zA4uIMDXKAh1NDkvQ1EkZKA= +github.com/go-redsync/redsync/v4 v4.13.0/go.mod h1:HMW4Q224GZQz6x1Xc7040Yfgacukdzu7ifTDAKiyErQ= +github.com/go-shiori/dom v0.0.0-20210627111528-4e4722cd0d65 h1:zx4B0AiwqKDQq+AgqxWeHwbbLJQeidq20hgfP+aMNWI= +github.com/go-shiori/dom v0.0.0-20210627111528-4e4722cd0d65/go.mod h1:NPO1+buE6TYOWhUI98/hXLHHJhunIpXRuvDN4xjkCoE= +github.com/go-shiori/go-readability v0.0.0-20231029095239-6b97d5aba789 h1:G6wSuUyCoLB9jrUokipsmFuRi8aJozt3phw/g9Sl4Xs= +github.com/go-shiori/go-readability v0.0.0-20231029095239-6b97d5aba789/go.mod h1:2DpZlTJO/ycxp/vsc/C11oUyveStOgIXB88SYV1lncI= +github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y= +github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= +github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= +github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= +github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= +github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/gogs/chardet v0.0.0-20191104214054-4b6791f73a28/go.mod h1:Pcatq5tYkCW2Q6yrR2VRHlbHpZ/R4/7qyL1TCF7vl14= +github.com/gogs/chardet v0.0.0-20211120154057-b7413eaefb8f h1:3BSP1Tbs2djlpprl7wCLuiqMaUh5SJkkzI2gDs+FgLs= +github.com/gogs/chardet v0.0.0-20211120154057-b7413eaefb8f/go.mod h1:Pcatq5tYkCW2Q6yrR2VRHlbHpZ/R4/7qyL1TCF7vl14= +github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= +github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= +github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/gomodule/redigo v1.8.9 h1:Sl3u+2BI/kk+VEatbj0scLdrFhjPmbxOc1myhDP41ws= +github.com/gomodule/redigo v1.8.9/go.mod h1:7ArFNvsTjH8GMMzB4uy1snslv2BwmginuMs06a1uzZE= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8 h1:FKHo8hFI3A+7w0aUQuYXQ+6EN5stWmeY/AZqtM8xk9k= +github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= +github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/grafana/pyroscope-go v1.1.2 h1:7vCfdORYQMCxIzI3NlYAs3FcBP760+gWuYWOyiVyYx8= +github.com/grafana/pyroscope-go v1.1.2/go.mod h1:HSSmHo2KRn6FasBA4vK7BMiQqyQq8KSuBKvrhkXxYPU= +github.com/grafana/pyroscope-go/godeltaprof v0.1.8 h1:iwOtYXeeVSAeYefJNaxDytgjKtUuKQbJqgAIjlnicKg= +github.com/grafana/pyroscope-go/godeltaprof v0.1.8/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I= +github.com/hamba/avro v1.8.0 h1:eCVrLX7UYThA3R3yBZ+rpmafA5qTc3ZjpTz6gYJoVGU= +github.com/hamba/avro v1.8.0/go.mod h1:NiGUcrLLT+CKfGu5REWQtD9OVPPYUGMVFiC+DE0lQfY= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= +github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= +github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= +github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= +github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= +github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +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/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4= +github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= +github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= +github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= +github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= +github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= +github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 h1:L0QtFUgDarD7Fpv9jeVMgy/+Ec0mtnmYuImjTz6dtDA= +github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY= +github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw= +github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= +github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= +github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= +github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= +github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= +github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= +github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= +github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= +github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg= +github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/labstack/echo/v4 v4.12.0 h1:IKpw49IMryVB2p1a4dzwlhP1O2Tf2E0Ir/450lH+kI0= +github.com/labstack/echo/v4 v4.12.0/go.mod h1:UP9Cr2DJXbOK3Kr9ONYzNowSh7HP0aG0ShAyycHSJvM= +github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0= +github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU= +github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= +github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= +github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= +github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= +github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= +github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= +github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ= +github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= +github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY= +github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg= +github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= +github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= +github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= +github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= +github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= +github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= +github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= +github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= +github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0= +github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= +github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= +github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= +github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= +github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE= +github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI= +github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0= +github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4= +github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g= +github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk= +github.com/multiformats/go-multicodec v0.9.0 h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg= +github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k= +github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U= +github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM= +github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8= +github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +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/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= +github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= +github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= +github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= +github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= +github.com/onsi/ginkgo/v2 v2.20.1 h1:YlVIbqct+ZmnEph770q9Q7NVAz4wwIiVNahee6JyUzo= +github.com/onsi/ginkgo/v2 v2.20.1/go.mod h1:lG9ey2Z29hR41WMVthyJBGUBcBhGOtoPF2VFMvBXFCI= +github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +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.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k= +github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY= +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.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug= +github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= +github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss= +github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8= +github.com/orlangure/gnomock v0.31.0 h1:dgjlQ8DYUPMyNwMZJuYBH+/GF+e7h3sloldPzIJF4k4= +github.com/orlangure/gnomock v0.31.0/go.mod h1:RagxeYv3bKi+li9Lio2Faw5t6Mcy4akkeqXzkgAS3w0= +github.com/ory/dockertest/v3 v3.10.0 h1:4K3z2VMe8Woe++invjaTB7VRyQXQy5UY+loujO4aNE4= +github.com/ory/dockertest/v3 v3.10.0/go.mod h1:nr57ZbRWMqfsdGdFNLHz5jjNdDb7VVFnzAeW1n5N1Lg= +github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= +github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= +github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ= +github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pressly/goose/v3 v3.22.0 h1:wd/7kNiPTuNAztWun7iaB98DrhulbWPrzMAaw2DEZNw= +github.com/pressly/goose/v3 v3.22.0/go.mod h1:yJM3qwSj2pp7aAaCvso096sguezamNb2OBgxCnh/EYg= +github.com/prometheus/client_golang v1.20.3 h1:oPksm4K8B+Vt35tUhw6GbSNSgVlVSBH0qELP/7u83l4= +github.com/prometheus/client_golang v1.20.3/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= +github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= +github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= +github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc= +github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8= +github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= +github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= +github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8= +github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= +github.com/redis/rueidis v1.0.45 h1:j7hfcqfLLIqgTK3IkxBhXdeJcP34t3XLXvorDLqXfgM= +github.com/redis/rueidis v1.0.45/go.mod h1:by+34b0cFXndxtYmPAHpoTHO5NkosDlBvhexoTURIxM= +github.com/redis/rueidis/mock v1.0.45 h1:r2LRiwOtFib8+NAuVxNmcdxL7IMUk3as9IGPzx2v5tA= +github.com/redis/rueidis/mock v1.0.45/go.mod h1:bjpk7ox5jwue03L8NpjgPBE91tLkm9Amla+XFYhaezc= +github.com/redis/rueidis/rueidiscompat v1.0.45 h1:G+3HIaETgtwr6aL6BOTFCa2DfpPDhxqcoiDn8cvd5Ps= +github.com/redis/rueidis/rueidiscompat v1.0.45/go.mod h1:JMw3cktmwNqsSl2npjcxrOfLa1L3rmj1Ox5aPHiDjOU= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs= +github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= +github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= +github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= +github.com/rss3-network/protocol-go v0.5.8 h1:w3XCFrqvNTXGHVCKM50rdmhgnj7BxY0+7FSGVvGCJeY= +github.com/rss3-network/protocol-go v0.5.8/go.mod h1:npcyduWt86uVbIi77xQaYk8eqltI9XNjk1FMGpjyIq0= +github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= +github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= +github.com/samber/lo v1.47.0 h1:z7RynLwP5nbyRscyvcD043DWYoOcYRv3mV8lBeqOCLc= +github.com/samber/lo v1.47.0/go.mod h1:RmDH9Ct32Qy3gduHQuKJ3gW1fMHAnE/fAzQuf6He5cU= +github.com/sebdah/goldie/v2 v2.5.3 h1:9ES/mNN+HNUbNWpVAlrzuZ7jE+Nrczbj8uFRjM7624Y= +github.com/sebdah/goldie/v2 v2.5.3/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI= +github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= +github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8= +github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I= +github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE= +github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas= +github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= +github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= +github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= +github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= +github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= +github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= +github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= +github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0= +github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= +github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM= +github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI= +github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg= +github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= +github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203 h1:QVqDTf3h2WHt08YuiTGPZLls0Wq99X9bWd0Q5ZSBesM= +github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203/go.mod h1:oqN97ltKNihBbwlX8dLpwxCl3+HnXKV/R0e+sRLd9C8= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= +github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= +github.com/tdewolff/minify/v2 v2.20.37 h1:Q97cx4STXCh1dlWDlNHZniE8BJ2EBL0+2b0n92BJQhw= +github.com/tdewolff/minify/v2 v2.20.37/go.mod h1:L1VYef/jwKw6Wwyk5A+T0mBjjn3mMPgmjjA688RNsxU= +github.com/tdewolff/parse/v2 v2.7.15 h1:hysDXtdGZIRF5UZXwpfn3ZWRbm+ru4l53/ajBRGpCTw= +github.com/tdewolff/parse/v2 v2.7.15/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA= +github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE= +github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739 h1:IkjBCtQOOjIn03u/dMQK9g+Iw9ewps4mCl1nB8Sscbo= +github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8= +github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= +github.com/tidwall/gjson v1.17.3 h1:bwWLZU7icoKRG+C+0PNwIKC6FCJO/Q3p2pZvuP0jN94= +github.com/tidwall/gjson v1.17.3/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= +github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= +github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= +github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= +github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= +github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= +github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= +github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +github.com/twmb/franz-go v1.17.1 h1:0LwPsbbJeJ9R91DPUHSEd4su82WJWcTY1Zzbgbg4CeQ= +github.com/twmb/franz-go v1.17.1/go.mod h1:NreRdJ2F7dziDY/m6VyspWd6sNxHKXdMZI42UfQ3GXM= +github.com/twmb/franz-go/pkg/kadm v1.13.0 h1:bJq4C2ZikUE2jh/wl9MtMTQ/kpmnBgVFh8XMQBEC+60= +github.com/twmb/franz-go/pkg/kadm v1.13.0/go.mod h1:VMvpfjz/szpH9WB+vGM+rteTzVv0djyHFimci9qm2C0= +github.com/twmb/franz-go/pkg/kmsg v1.8.0 h1:lAQB9Z3aMrIP9qF9288XcFf/ccaSxEitNA1CDTEIeTA= +github.com/twmb/franz-go/pkg/kmsg v1.8.0/go.mod h1:HzYEb8G3uu5XevZbtU0dVbkphaKTHk0X68N5ka4q6mU= +github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= +github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= +github.com/urfave/cli v1.22.1 h1:+mkCCcOFKPnCmVYVcURKps1Xe+3zP90gSYGNfRkjoIY= +github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs= +github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo= +github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= +github.com/vektah/gqlparser/v2 v2.5.11 h1:JJxLtXIoN7+3x6MBdtIP59TP1RANnY7pXOaDnADQSf8= +github.com/vektah/gqlparser/v2 v2.5.11/go.mod h1:1rCcfwB2ekJofmluGWXMSEnPMZgbxzwj6FaZ/4OT8Cc= +github.com/vincent-petithory/dataurl v1.0.0 h1:cXw+kPto8NLuJtlMsI152irrVw9fRDX8AbShPRpg2CI= +github.com/vincent-petithory/dataurl v1.0.0/go.mod h1:FHafX5vmDzyP+1CQATJn7WFKc9CvnvxyvZy6I1MrG/U= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo= +github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= +github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= +github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/yuin/goldmark v1.7.1 h1:3bajkSilaCbjdKVsKdZjZCLBNPL9pYzrCakKaf4U49U= +github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E= +github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw= +github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.50.0 h1:cEPbyTSEHlQR89XVlyo78gqluF8Y3oMeBkXGWzQsfXY= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.50.0/go.mod h1:DKdbWcT4GH1D0Y3Sqt/PFXt2naRKDWtU+eE6oLdFNA8= +go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw= +go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0 h1:dIIDULZJpgdiHz5tXrTgKIMLkus6jEFa7x5SOKcyR7E= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0/go.mod h1:jlRVBe7+Z1wyxFSUs48L6OBQZ5JwH2Hg/Vbl+t9rAgI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.29.0 h1:JAv0Jwtl01UFiyWZEMiJZBiTlv5A50zNs8lsthXqIio= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.29.0/go.mod h1:QNKLmUEAq2QUbPQUfvw4fmv0bgbK7UlOSFCnXyfvSNc= +go.opentelemetry.io/otel/exporters/prometheus v0.51.0 h1:G7uexXb/K3T+T9fNLCCKncweEtNEBMTO+46hKX5EdKw= +go.opentelemetry.io/otel/exporters/prometheus v0.51.0/go.mod h1:v0mFe5Kk7woIh938mrZBJBmENYquyA0IICrlYm4Y0t4= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.29.0 h1:X3ZjNp36/WlkSYx0ul2jw4PtbNEDDeLskw3VPsrpYM0= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.29.0/go.mod h1:2uL/xnOXh0CHOBFCWXz5u1A4GXLiW+0IQIzVbeOEQ0U= +go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc= +go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8= +go.opentelemetry.io/otel/sdk v1.29.0 h1:vkqKjk7gwhS8VaWb0POZKmIEDimRCMsopNYnriHyryo= +go.opentelemetry.io/otel/sdk v1.29.0/go.mod h1:pM8Dx5WKnvxLCb+8lG1PRNIDxu9g9b9g59Qr7hfAAok= +go.opentelemetry.io/otel/sdk/metric v1.29.0 h1:K2CfmJohnRgvZ9UAj2/FhIf/okdWcNdBwe1m8xFXiSY= +go.opentelemetry.io/otel/sdk/metric v1.29.0/go.mod h1:6zZLdCl2fkauYoZIOn/soQIDSWFmNSRcICarHfuhNJQ= +go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4= +go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ= +go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0= +go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8= +go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= +go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= +golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M= +golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= +golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= +golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20210505214959-0714010a04ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= +golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= +golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= +golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8= +golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= +golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo= +golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= +golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= +golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= +golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= +golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= +golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk= +golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224= +golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.24.0 h1:J1shsA93PJUEVaUSaay7UXAyE8aimq3GW0pjlolpa24= +golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd h1:BBOTEWLuuEGQy9n1y9MhVJ9Qt0BDu21X8qZs71/uPZo= +google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd/go.mod h1:fO8wJzT2zbQbAjbIoos1285VfEIYKDDY+Dt+WpTkh6g= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd h1:6TEm2ZxXoQmFWFlt1vNxvVOa1Q0dXFQD1m/rYjXmS0E= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc= +google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= +google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8= +gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gorm.io/driver/postgres v1.5.9 h1:DkegyItji119OlcaLjqN11kHoUgZ/j13E0jkJZgD6A8= +gorm.io/driver/postgres v1.5.9/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI= +gorm.io/gorm v1.23.6/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk= +gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg= +gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= +gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo= +gotest.tools/v3 v3.3.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= +lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI= +lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k= +modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI= +modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4= +modernc.org/libc v1.55.3 h1:AzcW1mhlPNrRtjS5sS+eW2ISCgSOLLNyFzRh/V3Qj/U= +modernc.org/libc v1.55.3/go.mod h1:qFXepLhz+JjFThQ4kzwzOjA/y/artDeg+pcYnY+Q83w= +modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= +modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= +modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E= +modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU= +modernc.org/sqlite v1.32.0 h1:6BM4uGza7bWypsw4fdLRsLxut6bHe4c58VeqjRgST8s= +modernc.org/sqlite v1.32.0/go.mod h1:UqoylwmTb9F+IqXERT8bW9zzOWN8qwAIcLdzeBZs4hA= +modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA= +modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0= +modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= +modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= +moul.io/zapgorm2 v1.3.0 h1:+CzUTMIcnafd0d/BvBce8T4uPn6DQnpIrz64cyixlkk= +moul.io/zapgorm2 v1.3.0/go.mod h1:nPVy6U9goFKHR4s+zfSo1xVFaoU7Qgd5DoCdOfzoCqs= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= From b9a115efdb98a051b3166433397bbba271ee5213 Mon Sep 17 00:00:00 2001 From: frank Date: Fri, 13 Sep 2024 02:16:44 +0800 Subject: [PATCH 17/19] fix: fix redeclaration issue in generated file --- go.sum | 18 +++++++++++++++ .../ethereum/contract/polymarket/contract.go | 2 +- .../polymarket/contract_ctf_exchange.go | 23 ------------------- 3 files changed, 19 insertions(+), 24 deletions(-) diff --git a/go.sum b/go.sum index e87c4764..3b6173c5 100644 --- a/go.sum +++ b/go.sum @@ -25,6 +25,8 @@ github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo github.com/andybalholm/cascadia v1.2.0/go.mod h1:YCyR8vOZT9aZ1CHEd8ap0gMVm2aFgxBp0T0eFw1RUQY= github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= +github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= +github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA= github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= @@ -104,6 +106,8 @@ github.com/ethereum/go-ethereum v1.13.15 h1:U7sSGYGo4SPjP6iNIifNoyIAiNjrmQkz6EwQ github.com/ethereum/go-ethereum v1.13.15/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/ferranbt/fastssz v0.1.2 h1:Dky6dXlngF6Qjc+EfDipAkE83N5I5DE68bY6O0VLNPk= +github.com/ferranbt/fastssz v0.1.2/go.mod h1:X5UPrE2u1UJjxHA8X54u04SBwdAQjG2sFtWs39YxyWs= github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA= github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= @@ -199,6 +203,8 @@ github.com/grafana/pyroscope-go v1.1.2 h1:7vCfdORYQMCxIzI3NlYAs3FcBP760+gWuYWOyi github.com/grafana/pyroscope-go v1.1.2/go.mod h1:HSSmHo2KRn6FasBA4vK7BMiQqyQq8KSuBKvrhkXxYPU= github.com/grafana/pyroscope-go/godeltaprof v0.1.8 h1:iwOtYXeeVSAeYefJNaxDytgjKtUuKQbJqgAIjlnicKg= github.com/grafana/pyroscope-go/godeltaprof v0.1.8/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= +github.com/graph-gophers/graphql-go v1.3.0 h1:Eb9x/q6MFpCLz7jBCiP/WTxjSDrYLR1QY41SORZyNJ0= +github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I= github.com/hamba/avro v1.8.0 h1:eCVrLX7UYThA3R3yBZ+rpmafA5qTc3ZjpTz6gYJoVGU= @@ -226,6 +232,12 @@ github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/influxdata/influxdb-client-go/v2 v2.13.0 h1:ioBbLmR5NMbAjP4UVA5r9b5xGjpABD7j65pI8kFphDM= +github.com/influxdata/influxdb-client-go/v2 v2.13.0/go.mod h1:k+spCbt9hcvqvUiz0sr5D8LolXHqAAOfPw9v/RIRHl4= +github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c h1:qSHzRbhzK8RdXOsAdfDgO49TtqC1oZ+acxPrkfTxcCs= +github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= +github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf h1:7JTmneyiNEwVBOHSjoMxiWAqB992atOeepeFYegn5RU= +github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= @@ -324,6 +336,8 @@ github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJm github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= +github.com/oapi-codegen/runtime v1.0.0 h1:P4rqFX5fMFWqRzY9M/3YF9+aPSPPB06IzP2P7oOxrWo= +github.com/oapi-codegen/runtime v1.0.0/go.mod h1:LmCUMQuPB4M/nLXilQXhHw+BLZdDb18B34OO356yJ/A= github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= @@ -345,12 +359,16 @@ github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQ github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss= github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8= +github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU= +github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/orlangure/gnomock v0.31.0 h1:dgjlQ8DYUPMyNwMZJuYBH+/GF+e7h3sloldPzIJF4k4= github.com/orlangure/gnomock v0.31.0/go.mod h1:RagxeYv3bKi+li9Lio2Faw5t6Mcy4akkeqXzkgAS3w0= github.com/ory/dockertest/v3 v3.10.0 h1:4K3z2VMe8Woe++invjaTB7VRyQXQy5UY+loujO4aNE4= github.com/ory/dockertest/v3 v3.10.0/go.mod h1:nr57ZbRWMqfsdGdFNLHz5jjNdDb7VVFnzAeW1n5N1Lg= github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= +github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM= +github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ= github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= diff --git a/provider/ethereum/contract/polymarket/contract.go b/provider/ethereum/contract/polymarket/contract.go index fe5a296e..fea1d8de 100644 --- a/provider/ethereum/contract/polymarket/contract.go +++ b/provider/ethereum/contract/polymarket/contract.go @@ -10,7 +10,7 @@ import ( //go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/CTFExchange.abi --pkg polymarket --type CTFExchange --out contract_ctf_exchange.go // Neg Risk CTF Exchange // https://polygonscan.com/address/0xc5d563a36ae78145c45a50134d48a1215220f80a -//go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/NegRiskCTFExchange.abi --pkg polymarket --type NegRiskCTFExchange --out contract_neg_risk_ctf_exchange.go +// go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/NegRiskCTFExchange.abi --pkg polymarket --type NegRiskCTFExchange --out contract_neg_risk_ctf_exchange.go // Condition Tokens // https://polygonscan.com/address/0x4D97DCd97eC945f40cF65F87097ACe5EA0476045 //go:generate go run --mod=mod github.com/ethereum/go-ethereum/cmd/abigen --abi ./abi/ConditionTokens.abi --pkg polymarket --type ConditionTokens --out contract_condition_tokens.go diff --git a/provider/ethereum/contract/polymarket/contract_ctf_exchange.go b/provider/ethereum/contract/polymarket/contract_ctf_exchange.go index 5e50527c..df54515f 100644 --- a/provider/ethereum/contract/polymarket/contract_ctf_exchange.go +++ b/provider/ethereum/contract/polymarket/contract_ctf_exchange.go @@ -29,29 +29,6 @@ var ( _ = abi.ConvertType ) -// Order is an auto generated low-level Go binding around an user-defined struct. -type Order struct { - Salt *big.Int - Maker common.Address - Signer common.Address - Taker common.Address - TokenId *big.Int - MakerAmount *big.Int - TakerAmount *big.Int - Expiration *big.Int - Nonce *big.Int - FeeRateBps *big.Int - Side uint8 - SignatureType uint8 - Signature []byte -} - -// OrderStatus is an auto generated low-level Go binding around an user-defined struct. -type OrderStatus struct { - IsFilledOrCancelled bool - Remaining *big.Int -} - // CTFExchangeMetaData contains all meta data concerning the CTFExchange contract. var CTFExchangeMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_ctf\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_proxyFactory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_safeFactory\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FeeTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidComplement\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenId\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MakingGtRemaining\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MismatchedTokenIds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCrossing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOperator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderFilledOrCancelled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLittleTokensReceived\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"FeeCharged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newAdminAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOperatorAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderCancelled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"OrderFilled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"takerOrderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"takerOrderMaker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"}],\"name\":\"OrdersMatched\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldProxyFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProxyFactory\",\"type\":\"address\"}],\"name\":\"ProxyFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedAdmin\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedOperator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldSafeFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newSafeFactory\",\"type\":\"address\"}],\"name\":\"SafeFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token0\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"TokenRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingUnpaused\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"name\":\"addAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator_\",\"type\":\"address\"}],\"name\":\"addOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"admins\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"cancelOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"cancelOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"domainSeparator\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"fillAmount\",\"type\":\"uint256\"}],\"name\":\"fillOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"fillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"fillOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateral\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getComplement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCtf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getMaxFeeRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"getOrderStatus\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"internalType\":\"structOrderStatus\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPolyProxyFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getPolyProxyWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getProxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getSafeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isAdmin\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"isValidNonce\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"takerOrder\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"makerOrders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"takerFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"makerFillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"matchOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"operators\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"orderStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parentCollectionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"registerToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"removeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"removeOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOperatorRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"safeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProxyFactory\",\"type\":\"address\"}],\"name\":\"setProxyFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newSafeFactory\",\"type\":\"address\"}],\"name\":\"setSafeFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"}],\"name\":\"validateComplement\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrder\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrderSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"validateTokenId\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", From 537fad971912448f186b0ee34ace6b0fa0b8b597 Mon Sep 17 00:00:00 2001 From: frank Date: Fri, 13 Sep 2024 02:20:03 +0800 Subject: [PATCH 18/19] fix: fix typo --- go.sum | 18 --------------- .../polymarket/contract_ctf_exchange.go | 23 +++++++++++++++++++ 2 files changed, 23 insertions(+), 18 deletions(-) diff --git a/go.sum b/go.sum index 3b6173c5..e87c4764 100644 --- a/go.sum +++ b/go.sum @@ -25,8 +25,6 @@ github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo github.com/andybalholm/cascadia v1.2.0/go.mod h1:YCyR8vOZT9aZ1CHEd8ap0gMVm2aFgxBp0T0eFw1RUQY= github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= -github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= -github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA= github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= @@ -106,8 +104,6 @@ github.com/ethereum/go-ethereum v1.13.15 h1:U7sSGYGo4SPjP6iNIifNoyIAiNjrmQkz6EwQ github.com/ethereum/go-ethereum v1.13.15/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/ferranbt/fastssz v0.1.2 h1:Dky6dXlngF6Qjc+EfDipAkE83N5I5DE68bY6O0VLNPk= -github.com/ferranbt/fastssz v0.1.2/go.mod h1:X5UPrE2u1UJjxHA8X54u04SBwdAQjG2sFtWs39YxyWs= github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA= github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= @@ -203,8 +199,6 @@ github.com/grafana/pyroscope-go v1.1.2 h1:7vCfdORYQMCxIzI3NlYAs3FcBP760+gWuYWOyi github.com/grafana/pyroscope-go v1.1.2/go.mod h1:HSSmHo2KRn6FasBA4vK7BMiQqyQq8KSuBKvrhkXxYPU= github.com/grafana/pyroscope-go/godeltaprof v0.1.8 h1:iwOtYXeeVSAeYefJNaxDytgjKtUuKQbJqgAIjlnicKg= github.com/grafana/pyroscope-go/godeltaprof v0.1.8/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= -github.com/graph-gophers/graphql-go v1.3.0 h1:Eb9x/q6MFpCLz7jBCiP/WTxjSDrYLR1QY41SORZyNJ0= -github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 h1:asbCHRVmodnJTuQ3qamDwqVOIjwqUPTYmYuemVOx+Ys= github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0/go.mod h1:ggCgvZ2r7uOoQjOyu2Y1NhHmEPPzzuhWgcza5M1Ji1I= github.com/hamba/avro v1.8.0 h1:eCVrLX7UYThA3R3yBZ+rpmafA5qTc3ZjpTz6gYJoVGU= @@ -232,12 +226,6 @@ github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= -github.com/influxdata/influxdb-client-go/v2 v2.13.0 h1:ioBbLmR5NMbAjP4UVA5r9b5xGjpABD7j65pI8kFphDM= -github.com/influxdata/influxdb-client-go/v2 v2.13.0/go.mod h1:k+spCbt9hcvqvUiz0sr5D8LolXHqAAOfPw9v/RIRHl4= -github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c h1:qSHzRbhzK8RdXOsAdfDgO49TtqC1oZ+acxPrkfTxcCs= -github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= -github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf h1:7JTmneyiNEwVBOHSjoMxiWAqB992atOeepeFYegn5RU= -github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= @@ -336,8 +324,6 @@ github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJm github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= -github.com/oapi-codegen/runtime v1.0.0 h1:P4rqFX5fMFWqRzY9M/3YF9+aPSPPB06IzP2P7oOxrWo= -github.com/oapi-codegen/runtime v1.0.0/go.mod h1:LmCUMQuPB4M/nLXilQXhHw+BLZdDb18B34OO356yJ/A= github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= @@ -359,16 +345,12 @@ github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQ github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss= github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8= -github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU= -github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/orlangure/gnomock v0.31.0 h1:dgjlQ8DYUPMyNwMZJuYBH+/GF+e7h3sloldPzIJF4k4= github.com/orlangure/gnomock v0.31.0/go.mod h1:RagxeYv3bKi+li9Lio2Faw5t6Mcy4akkeqXzkgAS3w0= github.com/ory/dockertest/v3 v3.10.0 h1:4K3z2VMe8Woe++invjaTB7VRyQXQy5UY+loujO4aNE4= github.com/ory/dockertest/v3 v3.10.0/go.mod h1:nr57ZbRWMqfsdGdFNLHz5jjNdDb7VVFnzAeW1n5N1Lg= github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= -github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM= -github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ= github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= diff --git a/provider/ethereum/contract/polymarket/contract_ctf_exchange.go b/provider/ethereum/contract/polymarket/contract_ctf_exchange.go index df54515f..5e50527c 100644 --- a/provider/ethereum/contract/polymarket/contract_ctf_exchange.go +++ b/provider/ethereum/contract/polymarket/contract_ctf_exchange.go @@ -29,6 +29,29 @@ var ( _ = abi.ConvertType ) +// Order is an auto generated low-level Go binding around an user-defined struct. +type Order struct { + Salt *big.Int + Maker common.Address + Signer common.Address + Taker common.Address + TokenId *big.Int + MakerAmount *big.Int + TakerAmount *big.Int + Expiration *big.Int + Nonce *big.Int + FeeRateBps *big.Int + Side uint8 + SignatureType uint8 + Signature []byte +} + +// OrderStatus is an auto generated low-level Go binding around an user-defined struct. +type OrderStatus struct { + IsFilledOrCancelled bool + Remaining *big.Int +} + // CTFExchangeMetaData contains all meta data concerning the CTFExchange contract. var CTFExchangeMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_ctf\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_proxyFactory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_safeFactory\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FeeTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidComplement\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenId\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MakingGtRemaining\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MismatchedTokenIds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCrossing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOperator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderFilledOrCancelled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLittleTokensReceived\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"FeeCharged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newAdminAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOperatorAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"NewOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderCancelled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"OrderFilled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"takerOrderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"takerOrderMaker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAssetId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"makerAmountFilled\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"takerAmountFilled\",\"type\":\"uint256\"}],\"name\":\"OrdersMatched\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldProxyFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProxyFactory\",\"type\":\"address\"}],\"name\":\"ProxyFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedAdmin\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedAdmin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"removedOperator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"RemovedOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldSafeFactory\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newSafeFactory\",\"type\":\"address\"}],\"name\":\"SafeFactoryUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token0\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"token1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"TokenRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"TradingUnpaused\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"name\":\"addAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator_\",\"type\":\"address\"}],\"name\":\"addOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"admins\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"cancelOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"cancelOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"domainSeparator\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"fillAmount\",\"type\":\"uint256\"}],\"name\":\"fillOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"fillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"fillOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateral\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getComplement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"}],\"name\":\"getConditionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCtf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getMaxFeeRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"getOrderStatus\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"internalType\":\"structOrderStatus\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPolyProxyFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getPolyProxyWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getProxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"getSafeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSafeFactoryImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isAdmin\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"usr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"isValidNonce\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"takerOrder\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder[]\",\"name\":\"makerOrders\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"takerFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"makerFillAmounts\",\"type\":\"uint256[]\"}],\"name\":\"matchOrders\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"operators\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"orderStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isFilledOrCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parentCollectionId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"name\":\"registerToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conditionId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"removeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"removeOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOperatorRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"safeFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProxyFactory\",\"type\":\"address\"}],\"name\":\"setProxyFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newSafeFactory\",\"type\":\"address\"}],\"name\":\"setSafeFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpauseTrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"token\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"complement\",\"type\":\"uint256\"}],\"name\":\"validateComplement\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrder\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"maker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"taker\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"makerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"takerAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeRateBps\",\"type\":\"uint256\"},{\"internalType\":\"enumSide\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"enumSignatureType\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structOrder\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"validateOrderSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"validateTokenId\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", From 0085061d281b9ba37de06798bb812ba179df3792 Mon Sep 17 00:00:00 2001 From: frank Date: Fri, 13 Sep 2024 11:02:25 +0800 Subject: [PATCH 19/19] feat: add a new test case for Neg Risk CTF Exchanges --- .../contract/polymarket/worker_test.go | 132 ++++++++++++++++++ 1 file changed, 132 insertions(+) diff --git a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go index 8a646b4d..0d9f79a9 100644 --- a/internal/engine/worker/decentralized/contract/polymarket/worker_test.go +++ b/internal/engine/worker/decentralized/contract/polymarket/worker_test.go @@ -356,6 +356,138 @@ func TestWorker_Polymarket(t *testing.T) { }, wantError: require.NoError, }, + + { + name: "Test One Offer Match Finalization (Neg Risk CTF Exchange)", + arguments: struct { + task *source.Task + config *config.Module + }{ + task: &source.Task{ + Network: network.Polygon, + ChainID: 137, + Header: ðereum.Header{ + Hash: common.HexToHash("0xbb77bd8cec66e1b978178a9ae51e8e5762da52279e566490514706e587d9ca9c"), + ParentHash: common.HexToHash("0xb48788849174ff6e11967df47801d050d92c598edc792a64c5ebad35adda797e"), + UncleHash: common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"), + Coinbase: common.HexToAddress("0x1B0840519a581f3779D0a10B77593d6D3894a76a"), + Number: lo.Must(new(big.Int).SetString("61758069", 0)), + GasLimit: 29362067, + GasUsed: 8062082, + Timestamp: 1726195550, + BaseFee: lo.Must(new(big.Int).SetString("47", 0)), + Transactions: nil, + }, + Transaction: ðereum.Transaction{ + BlockHash: common.HexToHash("0x15634482b5b971b4fee728f00017fa8cecba08a781f1a2d678bdb28a1391d479"), + From: common.HexToAddress("0x4595a3AD508Adf916ab082D0438515b190f41C84"), + Gas: 1500000, + GasPrice: lo.Must(new(big.Int).SetString("108000000047", 10)), + Hash: common.HexToHash("0x15634482b5b971b4fee728f00017fa8cecba08a781f1a2d678bdb28a1391d479"), + Input: hexutil.MustDecode("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"), + To: lo.ToPtr(common.HexToAddress("0x78769D50Be1763ed1CA0D5E878D93f05aabff29e")), + Value: lo.Must(new(big.Int).SetString("0", 0)), + Type: 2, + ChainID: lo.Must(new(big.Int).SetString("137", 0)), + }, + Receipt: ðereum.Receipt{ + BlockHash: common.HexToHash("0xbb77bd8cec66e1b978178a9ae51e8e5762da52279e566490514706e587d9ca9c"), + BlockNumber: lo.Must(new(big.Int).SetString("61758069", 0)), + ContractAddress: nil, + CumulativeGasUsed: 469158, + EffectiveGasPrice: hexutil.MustDecodeBig("0x19254d382f"), + GasUsed: 469158, + + Logs: []*ethereum.Log{{ + Address: common.HexToAddress("0xC5d563A36AE78145C45a50134d48A1215220f80a"), + Topics: []common.Hash{ + common.HexToHash("0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6"), + common.HexToHash("0xdc61a7f59bd41947b3035b57df69d23d8714fd0e791a5b4dd24985c57da7a872"), + common.HexToHash("0x000000000000000000000000255c5785d7a46a3e412daff3b3bb3ed0b278f062"), + common.HexToHash("0x0000000000000000000000009d5697f60c023d161603d8884b60aae8c24aa170"), + }, + Data: hexutil.MustDecode("0x0000000000000000000000000000000000000000000000000000000000000000eac62972f91654a3017bf68033bc24f248ff437a12e88a7bb2af629c44de0568000000000000000000000000000000000000000000000000000000000932a3800000000000000000000000000000000000000000000000000000000020d96c800000000000000000000000000000000000000000000000000000000000000000"), + BlockNumber: lo.Must(new(big.Int).SetString("61758069", 0)), + TransactionHash: common.HexToHash("0x15634482b5b971b4fee728f00017fa8cecba08a781f1a2d678bdb28a1391d479"), + Index: 4, + Removed: false, + }}, + Status: 1, + TransactionHash: common.HexToHash("0x15634482b5b971b4fee728f00017fa8cecba08a781f1a2d678bdb28a1391d479"), + TransactionIndex: 0, + }, + }, + config: &config.Module{ + Network: network.Polygon, + Endpoint: config.Endpoint{ + URL: endpoint.MustGet(network.Polygon), + }, + }, + }, + want: &activityx.Activity{ + ID: "0x15634482b5b971b4fee728f00017fa8cecba08a781f1a2d678bdb28a1391d479", + Network: network.Polygon, + Index: 0, + From: "0x4595a3AD508Adf916ab082D0438515b190f41C84", + To: "0x78769D50Be1763ed1CA0D5E878D93f05aabff29e", + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + Fee: &activityx.Fee{ + Amount: lo.Must(decimal.NewFromString("50669064022050426")), + Decimal: 18, + }, + Calldata: &activityx.Calldata{ + FunctionHash: "0xd2539b37", + }, + Actions: []*activityx.Action{ + { + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + From: "0x9D5697f60c023d161603d8884B60AAE8C24AA170", + To: "0x255C5785D7A46a3e412daff3B3BB3eD0B278f062", + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeBuy, + Token: metadata.Token{ + Address: lo.ToPtr("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"), + ID: lo.ToPtr(lo.Must(decimal.NewFromString("106191328358576540351439267765925450329859429577455659884974413809922495874408"))), + Value: lo.ToPtr(lo.Must(decimal.NewFromString("551120000"))), + Standard: metadata.StandardERC1155, + }, + Cost: &metadata.Token{ + Value: lo.ToPtr(lo.Must(decimal.NewFromString("154313600"))), + Name: "Polygon", + Symbol: "MATIC", + Decimals: 18, + }, + }, + }, + { + Type: typex.CollectibleTrade, + Platform: workerx.PlatformPolymarket.String(), + From: "0x255C5785D7A46a3e412daff3B3BB3eD0B278f062", + To: "0x9D5697f60c023d161603d8884B60AAE8C24AA170", + Metadata: metadata.CollectibleTrade{ + Action: metadata.ActionCollectibleTradeSell, + Token: metadata.Token{ + Address: lo.ToPtr("0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"), + ID: lo.ToPtr(lo.Must(decimal.NewFromString("106191328358576540351439267765925450329859429577455659884974413809922495874408"))), + Value: lo.ToPtr(lo.Must(decimal.NewFromString("551120000"))), + Standard: metadata.StandardERC1155, + }, + Cost: &metadata.Token{ + Value: lo.ToPtr(lo.Must(decimal.NewFromString("154313600"))), + Name: "Polygon", + Symbol: "MATIC", + Decimals: 18, + }, + }, + }, + }, + Status: true, + Timestamp: 1726195550, + }, + wantError: require.NoError, + }, } for _, testcase := range testcases {