From 8efaf7fd4b2c667ff22f7fd943ca29bc62edef33 Mon Sep 17 00:00:00 2001 From: Kunjal Tandel Date: Mon, 10 Nov 2025 23:04:50 +0530 Subject: [PATCH 1/2] feat: - added evm contract calls for merkle tree - removed cosmos contract client - parallel verification of both base and super proof --- README.md | 7 +- clients/MerkleTreeStorage.go | 84 ++ clients/cosmos.go | 165 --- contracts/MerkleTreeStorage.go | 1162 +++++++++++++++++ go.mod | 50 +- go.sum | 180 ++- main.go | 54 +- node/verifier.go | 49 +- risc0-merkle-service/.gitignore | 6 - risc0-merkle-service/Cargo.toml | 11 - risc0-merkle-service/cli/Cargo.toml | 14 - risc0-merkle-service/cli/src/main.rs | 142 -- risc0-merkle-service/host/Cargo.toml | 17 - risc0-merkle-service/host/src/main.rs | 115 -- risc0-merkle-service/methods/Cargo.toml | 13 - risc0-merkle-service/methods/build.rs | 3 - risc0-merkle-service/methods/guest/Cargo.toml | 14 - .../methods/guest/src/main.rs | 171 --- risc0-merkle-service/methods/src/lib.rs | 1 - risc0-merkle-service/run_merkle_tree.sh | 80 -- risc0-merkle-service/rust-toolchain.toml | 4 - 21 files changed, 1503 insertions(+), 839 deletions(-) create mode 100644 clients/MerkleTreeStorage.go delete mode 100644 clients/cosmos.go create mode 100644 contracts/MerkleTreeStorage.go delete mode 100644 risc0-merkle-service/.gitignore delete mode 100644 risc0-merkle-service/Cargo.toml delete mode 100644 risc0-merkle-service/cli/Cargo.toml delete mode 100644 risc0-merkle-service/cli/src/main.rs delete mode 100644 risc0-merkle-service/host/Cargo.toml delete mode 100644 risc0-merkle-service/host/src/main.rs delete mode 100644 risc0-merkle-service/methods/Cargo.toml delete mode 100644 risc0-merkle-service/methods/build.rs delete mode 100644 risc0-merkle-service/methods/guest/Cargo.toml delete mode 100644 risc0-merkle-service/methods/guest/src/main.rs delete mode 100644 risc0-merkle-service/methods/src/lib.rs delete mode 100755 risc0-merkle-service/run_merkle_tree.sh delete mode 100644 risc0-merkle-service/rust-toolchain.toml diff --git a/README.md b/README.md index 1721237..4b48f1a 100644 --- a/README.md +++ b/README.md @@ -29,9 +29,10 @@ Key features: Configure environment variables or in .env file ```env -GRPC_URL=grpc.testnet.layeredge.io:9090 -CONTRACT_ADDR=cosmos1ufs3tlq4umljk0qfe8k5ya0x6hpavn897u2cnf9k0en9jr7qarqqt56709 -ZK_PROVER_URL=http://127.0.0.1:3001 +RPC_URL=https://rpc.layeredge.io +MERKLE_TREE_STORAGE_CONTRACT_ADDRESS=0x57bEBD1b51dF9F221F763a708591c1E72D2379D6 +SUPER_PROOF_CONTRACT_ADDRESS=0x7f9EBd5DA0829bdB6CDFF45BbA0D68c0cae39364 +ZK_PROVER_URL=http://127.0.0.1:3000 API_REQUEST_TIMEOUT=100 POINTS_API=http://127.0.0.1:8080 PRIVATE_KEY='cli-node-private-key' diff --git a/clients/MerkleTreeStorage.go b/clients/MerkleTreeStorage.go new file mode 100644 index 0000000..2ffee6a --- /dev/null +++ b/clients/MerkleTreeStorage.go @@ -0,0 +1,84 @@ +package clients + +import ( + "fmt" + "math/big" + + "github.com/Layer-Edge/light-node/contracts" + "github.com/Layer-Edge/light-node/utils" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/ethclient" +) + +type MerkleTreeData struct { + Root common.Hash + Owner common.Address + LeafCount *big.Int + CreatedAt *big.Int + Leaves []string +} + +type MerkleTreeClient struct { + rpc *ethclient.Client + contract *contracts.MerkleTreeStorage +} + +func (mtc *MerkleTreeClient) Init(merkleTreeStorageContractAddress string) error { + layerEdgeRPC := utils.GetEnv("RPC_URL", "https://rpc.layeredge.io") + layerEdgeClient, err := ethclient.Dial(layerEdgeRPC) + if err != nil { + return fmt.Errorf("error creating layerEdgeClient: %v", err) + } + + contractAddress := common.HexToAddress(merkleTreeStorageContractAddress) + merkleTreeStorageContract, err := contracts.NewMerkleTreeStorage(contractAddress, layerEdgeClient) + if err != nil { + return fmt.Errorf("error creating merkleTreeStorageContract: %v", err) + } + + mtc.rpc = layerEdgeClient + mtc.contract = merkleTreeStorageContract + + return nil +} + +func (mtc *MerkleTreeClient) GetAllRoots() ([]common.Hash, error) { + roots, err := mtc.contract.GetAllRoots(nil) + if err != nil { + return nil, fmt.Errorf("error getting all roots: %v", err) + } + + // Convert [][32]byte to []common.Hash + hashRoots := make([]common.Hash, len(roots)) + for i, root := range roots { + hashRoots[i] = common.BytesToHash(root[:]) + } + + return hashRoots, nil +} + +func (mtc *MerkleTreeClient) GetTreeInfo(root common.Hash) (*MerkleTreeData, error) { + treeInfo, err := mtc.contract.GetTreeInfo(nil, root) + if err != nil { + return nil, fmt.Errorf("error getting tree info: %v", err) + } + // Convert [][]byte to []string + leaves := make([]string, len(treeInfo.Leaves)) + for i, leaf := range treeInfo.Leaves { + leaves[i] = string(leaf) + } + + return &MerkleTreeData{ + Root: root, + Owner: treeInfo.Owner, + LeafCount: treeInfo.LeafCount, + CreatedAt: treeInfo.CreatedAt, + Leaves: leaves, + }, nil +} + +func (mtc *MerkleTreeClient) Close() { + if mtc.rpc != nil { + mtc.rpc.Close() + } +} diff --git a/clients/cosmos.go b/clients/cosmos.go deleted file mode 100644 index b70e12b..0000000 --- a/clients/cosmos.go +++ /dev/null @@ -1,165 +0,0 @@ -package clients - -import ( - "context" - "encoding/json" - "fmt" - "log" - - wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types" - "github.com/Layer-Edge/light-node/utils" - "google.golang.org/grpc" - "google.golang.org/grpc/credentials/insecure" -) - -// ClientConfig holds all configurable parameters for the clients package -type ClientConfig struct { - GrpcURL string - ContractAddr string -} - -// Global configuration with default values -var globalClientConfig = ClientConfig{ - GrpcURL: "grpc.testnet.layeredge.io:9090", // Default gRPC endpoint - ContractAddr: "cosmos1ufs3tlq4umljk0qfe8k5ya0x6hpavn897u2cnf9k0en9jr7qarqqt56709", // Default contract address -} - -// InitClientConfig initializes the client configuration with environment variables or defaults -func InitClientConfig() { - globalClientConfig.GrpcURL = utils.GetEnv("GRPC_URL", "grpc.testnet.layeredge.io:9090") - globalClientConfig.ContractAddr = utils.GetEnv("CONTRACT_ADDR", "cosmos1ufs3tlq4umljk0qfe8k5ya0x6hpavn897u2cnf9k0en9jr7qarqqt56709") - - log.Printf("Initialized client configuration: GRPC_URL=%s, CONTRACT_ADDR=%s", - globalClientConfig.GrpcURL, globalClientConfig.ContractAddr) -} - -// SetClientConfig allows overriding the configuration programmatically -func SetClientConfig(config ClientConfig) { - globalClientConfig = config - log.Printf("Updated client configuration: GRPC_URL=%s, CONTRACT_ADDR=%s", - globalClientConfig.GrpcURL, globalClientConfig.ContractAddr) -} - -// GetClientConfig returns a copy of the current configuration -func GetClientConfig() ClientConfig { - return globalClientConfig -} - -type MerkleTree struct { - Root string `json:"root"` - Leaves []string `json:"leaves"` - Metadata string `json:"metadata"` -} - -type QueryGetTree struct { - GetMerkleTree struct { - ID string `json:"id"` - } `json:"get_merkle_tree"` -} - -type QueryListTreeIDs struct { - ListMerkleTreeIds struct { - } `json:"list_merkle_tree_ids"` -} - -type CosmosQueryClient struct { - conn *grpc.ClientConn - queryClient wasmtypes.QueryClient - config ClientConfig -} - -func (cqc *CosmosQueryClient) Init() error { - globalClientConfig.GrpcURL = utils.GetEnv("GRPC_URL", "grpc.testnet.layeredge.io:9090") - globalClientConfig.ContractAddr = utils.GetEnv("CONTRACT_ADDR", "cosmos1ufs3tlq4umljk0qfe8k5ya0x6hpavn897u2cnf9k0en9jr7qarqqt56709") - // Use the global configuration - cqc.config = globalClientConfig - - // Connect to gRPC client - conn, err := grpc.Dial(cqc.config.GrpcURL, grpc.WithTransportCredentials(insecure.NewCredentials())) - if err != nil { - return fmt.Errorf("failed to connect to gRPC at %s: %v", cqc.config.GrpcURL, err) - } - - cqc.conn = conn - cqc.queryClient = wasmtypes.NewQueryClient(conn) - return nil -} - -// InitWithConfig initializes the client with a specific configuration -func (cqc *CosmosQueryClient) InitWithConfig(config ClientConfig) error { - cqc.config = config - - // Connect to gRPC client - conn, err := grpc.Dial(cqc.config.GrpcURL, grpc.WithTransportCredentials(insecure.NewCredentials())) - if err != nil { - return fmt.Errorf("failed to connect to gRPC at %s: %v", cqc.config.GrpcURL, err) - } - - cqc.conn = conn - cqc.queryClient = wasmtypes.NewQueryClient(conn) - return nil -} - -func (cqc *CosmosQueryClient) Close() { - if cqc.conn != nil { - cqc.conn.Close() - } -} - -func (cqc *CosmosQueryClient) GetMerkleTreeData(id string) (*MerkleTree, error) { - query := QueryGetTree{} - query.GetMerkleTree.ID = id - - queryBytes, err := json.Marshal(query) - if err != nil { - return nil, fmt.Errorf("failed to marshal query: %v", err) - } - - res, err := cqc.queryClient.SmartContractState( - context.Background(), - &wasmtypes.QuerySmartContractStateRequest{ - Address: cqc.config.ContractAddr, - QueryData: queryBytes, - }, - ) - if err != nil { - return nil, fmt.Errorf("failed to query contract: %v", err) - } - - // Parse response JSON into struct - var tree MerkleTree - err = json.Unmarshal(res.Data, &tree) - if err != nil { - return nil, fmt.Errorf("failed to unmarshal tree data: %v", err) - } - - return &tree, nil -} - -func (cqc *CosmosQueryClient) ListMerkleTreeIds() ([]string, error) { - query := QueryListTreeIDs{} - - queryBytes, err := json.Marshal(query) - if err != nil { - return nil, fmt.Errorf("failed to marshal query: %v", err) - } - - res, err := cqc.queryClient.SmartContractState( - context.Background(), - &wasmtypes.QuerySmartContractStateRequest{ - Address: cqc.config.ContractAddr, - QueryData: queryBytes, - }, - ) - if err != nil { - return nil, fmt.Errorf("failed to query contract: %v", err) - } - - // Parse response JSON into struct - var treeIds []string - err = json.Unmarshal(res.Data, &treeIds) - if err != nil { - return nil, fmt.Errorf("failed to unmarshal tree data: %v", err) - } - return treeIds, nil -} diff --git a/contracts/MerkleTreeStorage.go b/contracts/MerkleTreeStorage.go new file mode 100644 index 0000000..ae09bbc --- /dev/null +++ b/contracts/MerkleTreeStorage.go @@ -0,0 +1,1162 @@ +package contracts + +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 +) + +// MerkleTreeStorageMetaData contains all meta data concerning the MerkleTreeStorage contract. +var MerkleTreeStorageMetaData = &bind.MetaData{ + ABI: `[{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"bytes32[]","name":"leaves","type":"bytes32[]"}],"name":"TreeCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"UPGRADE_INTERFACE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllRoots","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTreeCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"name":"getTreeInfo","outputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"leafCount","type":"uint256"},{"internalType":"uint256","name":"createdAt","type":"uint256"},{"internalType":"bytes32[]","name":"leaves","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"initialOwner","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"bytes32[]","name":"leaves","type":"bytes32[]"}],"name":"storeTree","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"name":"treeExists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"}]`, + Bin: "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", +} + +// MerkleTreeStorageABI is the input ABI used to generate the binding from. +// Deprecated: Use MerkleTreeStorageMetaData.ABI instead. +var MerkleTreeStorageABI = MerkleTreeStorageMetaData.ABI + +// MerkleTreeStorageBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use MerkleTreeStorageMetaData.Bin instead. +var MerkleTreeStorageBin = MerkleTreeStorageMetaData.Bin + +// DeployMerkleTreeStorage deploys a new Ethereum contract, binding an instance of MerkleTreeStorage to it. +func DeployMerkleTreeStorage(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MerkleTreeStorage, error) { + parsed, err := MerkleTreeStorageMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(MerkleTreeStorageBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &MerkleTreeStorage{MerkleTreeStorageCaller: MerkleTreeStorageCaller{contract: contract}, MerkleTreeStorageTransactor: MerkleTreeStorageTransactor{contract: contract}, MerkleTreeStorageFilterer: MerkleTreeStorageFilterer{contract: contract}}, nil +} + +// MerkleTreeStorage is an auto generated Go binding around an Ethereum contract. +type MerkleTreeStorage struct { + MerkleTreeStorageCaller // Read-only binding to the contract + MerkleTreeStorageTransactor // Write-only binding to the contract + MerkleTreeStorageFilterer // Log filterer for contract events +} + +// MerkleTreeStorageCaller is an auto generated read-only Go binding around an Ethereum contract. +type MerkleTreeStorageCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MerkleTreeStorageTransactor is an auto generated write-only Go binding around an Ethereum contract. +type MerkleTreeStorageTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MerkleTreeStorageFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type MerkleTreeStorageFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MerkleTreeStorageSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type MerkleTreeStorageSession struct { + Contract *MerkleTreeStorage // 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 +} + +// MerkleTreeStorageCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type MerkleTreeStorageCallerSession struct { + Contract *MerkleTreeStorageCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// MerkleTreeStorageTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type MerkleTreeStorageTransactorSession struct { + Contract *MerkleTreeStorageTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MerkleTreeStorageRaw is an auto generated low-level Go binding around an Ethereum contract. +type MerkleTreeStorageRaw struct { + Contract *MerkleTreeStorage // Generic contract binding to access the raw methods on +} + +// MerkleTreeStorageCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type MerkleTreeStorageCallerRaw struct { + Contract *MerkleTreeStorageCaller // Generic read-only contract binding to access the raw methods on +} + +// MerkleTreeStorageTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type MerkleTreeStorageTransactorRaw struct { + Contract *MerkleTreeStorageTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewMerkleTreeStorage creates a new instance of MerkleTreeStorage, bound to a specific deployed contract. +func NewMerkleTreeStorage(address common.Address, backend bind.ContractBackend) (*MerkleTreeStorage, error) { + contract, err := bindMerkleTreeStorage(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &MerkleTreeStorage{MerkleTreeStorageCaller: MerkleTreeStorageCaller{contract: contract}, MerkleTreeStorageTransactor: MerkleTreeStorageTransactor{contract: contract}, MerkleTreeStorageFilterer: MerkleTreeStorageFilterer{contract: contract}}, nil +} + +// NewMerkleTreeStorageCaller creates a new read-only instance of MerkleTreeStorage, bound to a specific deployed contract. +func NewMerkleTreeStorageCaller(address common.Address, caller bind.ContractCaller) (*MerkleTreeStorageCaller, error) { + contract, err := bindMerkleTreeStorage(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &MerkleTreeStorageCaller{contract: contract}, nil +} + +// NewMerkleTreeStorageTransactor creates a new write-only instance of MerkleTreeStorage, bound to a specific deployed contract. +func NewMerkleTreeStorageTransactor(address common.Address, transactor bind.ContractTransactor) (*MerkleTreeStorageTransactor, error) { + contract, err := bindMerkleTreeStorage(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &MerkleTreeStorageTransactor{contract: contract}, nil +} + +// NewMerkleTreeStorageFilterer creates a new log filterer instance of MerkleTreeStorage, bound to a specific deployed contract. +func NewMerkleTreeStorageFilterer(address common.Address, filterer bind.ContractFilterer) (*MerkleTreeStorageFilterer, error) { + contract, err := bindMerkleTreeStorage(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &MerkleTreeStorageFilterer{contract: contract}, nil +} + +// bindMerkleTreeStorage binds a generic wrapper to an already deployed contract. +func bindMerkleTreeStorage(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := MerkleTreeStorageMetaData.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 (_MerkleTreeStorage *MerkleTreeStorageRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _MerkleTreeStorage.Contract.MerkleTreeStorageCaller.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 (_MerkleTreeStorage *MerkleTreeStorageRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.MerkleTreeStorageTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_MerkleTreeStorage *MerkleTreeStorageRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.MerkleTreeStorageTransactor.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 (_MerkleTreeStorage *MerkleTreeStorageCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _MerkleTreeStorage.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 (_MerkleTreeStorage *MerkleTreeStorageTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_MerkleTreeStorage *MerkleTreeStorageTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.contract.Transact(opts, method, params...) +} + +// UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. +// +// Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) +func (_MerkleTreeStorage *MerkleTreeStorageCaller) UPGRADEINTERFACEVERSION(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _MerkleTreeStorage.contract.Call(opts, &out, "UPGRADE_INTERFACE_VERSION") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. +// +// Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) +func (_MerkleTreeStorage *MerkleTreeStorageSession) UPGRADEINTERFACEVERSION() (string, error) { + return _MerkleTreeStorage.Contract.UPGRADEINTERFACEVERSION(&_MerkleTreeStorage.CallOpts) +} + +// UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. +// +// Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) +func (_MerkleTreeStorage *MerkleTreeStorageCallerSession) UPGRADEINTERFACEVERSION() (string, error) { + return _MerkleTreeStorage.Contract.UPGRADEINTERFACEVERSION(&_MerkleTreeStorage.CallOpts) +} + +// GetAllRoots is a free data retrieval call binding the contract method 0xbada8fc4. +// +// Solidity: function getAllRoots() view returns(bytes32[]) +func (_MerkleTreeStorage *MerkleTreeStorageCaller) GetAllRoots(opts *bind.CallOpts) ([][32]byte, error) { + var out []interface{} + err := _MerkleTreeStorage.contract.Call(opts, &out, "getAllRoots") + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// GetAllRoots is a free data retrieval call binding the contract method 0xbada8fc4. +// +// Solidity: function getAllRoots() view returns(bytes32[]) +func (_MerkleTreeStorage *MerkleTreeStorageSession) GetAllRoots() ([][32]byte, error) { + return _MerkleTreeStorage.Contract.GetAllRoots(&_MerkleTreeStorage.CallOpts) +} + +// GetAllRoots is a free data retrieval call binding the contract method 0xbada8fc4. +// +// Solidity: function getAllRoots() view returns(bytes32[]) +func (_MerkleTreeStorage *MerkleTreeStorageCallerSession) GetAllRoots() ([][32]byte, error) { + return _MerkleTreeStorage.Contract.GetAllRoots(&_MerkleTreeStorage.CallOpts) +} + +// GetOwner is a free data retrieval call binding the contract method 0xdeb931a2. +// +// Solidity: function getOwner(bytes32 merkleRoot) view returns(address) +func (_MerkleTreeStorage *MerkleTreeStorageCaller) GetOwner(opts *bind.CallOpts, merkleRoot [32]byte) (common.Address, error) { + var out []interface{} + err := _MerkleTreeStorage.contract.Call(opts, &out, "getOwner", merkleRoot) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetOwner is a free data retrieval call binding the contract method 0xdeb931a2. +// +// Solidity: function getOwner(bytes32 merkleRoot) view returns(address) +func (_MerkleTreeStorage *MerkleTreeStorageSession) GetOwner(merkleRoot [32]byte) (common.Address, error) { + return _MerkleTreeStorage.Contract.GetOwner(&_MerkleTreeStorage.CallOpts, merkleRoot) +} + +// GetOwner is a free data retrieval call binding the contract method 0xdeb931a2. +// +// Solidity: function getOwner(bytes32 merkleRoot) view returns(address) +func (_MerkleTreeStorage *MerkleTreeStorageCallerSession) GetOwner(merkleRoot [32]byte) (common.Address, error) { + return _MerkleTreeStorage.Contract.GetOwner(&_MerkleTreeStorage.CallOpts, merkleRoot) +} + +// GetTreeCount is a free data retrieval call binding the contract method 0x5028f70b. +// +// Solidity: function getTreeCount() view returns(uint256) +func (_MerkleTreeStorage *MerkleTreeStorageCaller) GetTreeCount(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _MerkleTreeStorage.contract.Call(opts, &out, "getTreeCount") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetTreeCount is a free data retrieval call binding the contract method 0x5028f70b. +// +// Solidity: function getTreeCount() view returns(uint256) +func (_MerkleTreeStorage *MerkleTreeStorageSession) GetTreeCount() (*big.Int, error) { + return _MerkleTreeStorage.Contract.GetTreeCount(&_MerkleTreeStorage.CallOpts) +} + +// GetTreeCount is a free data retrieval call binding the contract method 0x5028f70b. +// +// Solidity: function getTreeCount() view returns(uint256) +func (_MerkleTreeStorage *MerkleTreeStorageCallerSession) GetTreeCount() (*big.Int, error) { + return _MerkleTreeStorage.Contract.GetTreeCount(&_MerkleTreeStorage.CallOpts) +} + +// GetTreeInfo is a free data retrieval call binding the contract method 0x84ab4db1. +// +// Solidity: function getTreeInfo(bytes32 merkleRoot) view returns(address owner, uint256 leafCount, uint256 createdAt, bytes[] leaves) +func (_MerkleTreeStorage *MerkleTreeStorageCaller) GetTreeInfo(opts *bind.CallOpts, merkleRoot [32]byte) (struct { + Owner common.Address + LeafCount *big.Int + CreatedAt *big.Int + Leaves [][]byte +}, error) { + var out []interface{} + err := _MerkleTreeStorage.contract.Call(opts, &out, "getTreeInfo", merkleRoot) + + outstruct := new(struct { + Owner common.Address + LeafCount *big.Int + CreatedAt *big.Int + Leaves [][]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.Owner = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.LeafCount = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.CreatedAt = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + outstruct.Leaves = *abi.ConvertType(out[3], new([][]byte)).(*[][]byte) + + return *outstruct, err + +} + +// GetTreeInfo is a free data retrieval call binding the contract method 0x84ab4db1. +// +// Solidity: function getTreeInfo(bytes32 merkleRoot) view returns(address owner, uint256 leafCount, uint256 createdAt, bytes[] leaves) +func (_MerkleTreeStorage *MerkleTreeStorageSession) GetTreeInfo(merkleRoot [32]byte) (struct { + Owner common.Address + LeafCount *big.Int + CreatedAt *big.Int + Leaves [][]byte +}, error) { + return _MerkleTreeStorage.Contract.GetTreeInfo(&_MerkleTreeStorage.CallOpts, merkleRoot) +} + +// GetTreeInfo is a free data retrieval call binding the contract method 0x84ab4db1. +// +// Solidity: function getTreeInfo(bytes32 merkleRoot) view returns(address owner, uint256 leafCount, uint256 createdAt, bytes[] leaves) +func (_MerkleTreeStorage *MerkleTreeStorageCallerSession) GetTreeInfo(merkleRoot [32]byte) (struct { + Owner common.Address + LeafCount *big.Int + CreatedAt *big.Int + Leaves [][]byte +}, error) { + return _MerkleTreeStorage.Contract.GetTreeInfo(&_MerkleTreeStorage.CallOpts, merkleRoot) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_MerkleTreeStorage *MerkleTreeStorageCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _MerkleTreeStorage.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_MerkleTreeStorage *MerkleTreeStorageSession) Owner() (common.Address, error) { + return _MerkleTreeStorage.Contract.Owner(&_MerkleTreeStorage.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_MerkleTreeStorage *MerkleTreeStorageCallerSession) Owner() (common.Address, error) { + return _MerkleTreeStorage.Contract.Owner(&_MerkleTreeStorage.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_MerkleTreeStorage *MerkleTreeStorageCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _MerkleTreeStorage.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_MerkleTreeStorage *MerkleTreeStorageSession) ProxiableUUID() ([32]byte, error) { + return _MerkleTreeStorage.Contract.ProxiableUUID(&_MerkleTreeStorage.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_MerkleTreeStorage *MerkleTreeStorageCallerSession) ProxiableUUID() ([32]byte, error) { + return _MerkleTreeStorage.Contract.ProxiableUUID(&_MerkleTreeStorage.CallOpts) +} + +// TreeExists is a free data retrieval call binding the contract method 0xf26f68bf. +// +// Solidity: function treeExists(bytes32 merkleRoot) view returns(bool) +func (_MerkleTreeStorage *MerkleTreeStorageCaller) TreeExists(opts *bind.CallOpts, merkleRoot [32]byte) (bool, error) { + var out []interface{} + err := _MerkleTreeStorage.contract.Call(opts, &out, "treeExists", merkleRoot) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// TreeExists is a free data retrieval call binding the contract method 0xf26f68bf. +// +// Solidity: function treeExists(bytes32 merkleRoot) view returns(bool) +func (_MerkleTreeStorage *MerkleTreeStorageSession) TreeExists(merkleRoot [32]byte) (bool, error) { + return _MerkleTreeStorage.Contract.TreeExists(&_MerkleTreeStorage.CallOpts, merkleRoot) +} + +// TreeExists is a free data retrieval call binding the contract method 0xf26f68bf. +// +// Solidity: function treeExists(bytes32 merkleRoot) view returns(bool) +func (_MerkleTreeStorage *MerkleTreeStorageCallerSession) TreeExists(merkleRoot [32]byte) (bool, error) { + return _MerkleTreeStorage.Contract.TreeExists(&_MerkleTreeStorage.CallOpts, merkleRoot) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address initialOwner) returns() +func (_MerkleTreeStorage *MerkleTreeStorageTransactor) Initialize(opts *bind.TransactOpts, initialOwner common.Address) (*types.Transaction, error) { + return _MerkleTreeStorage.contract.Transact(opts, "initialize", initialOwner) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address initialOwner) returns() +func (_MerkleTreeStorage *MerkleTreeStorageSession) Initialize(initialOwner common.Address) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.Initialize(&_MerkleTreeStorage.TransactOpts, initialOwner) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address initialOwner) returns() +func (_MerkleTreeStorage *MerkleTreeStorageTransactorSession) Initialize(initialOwner common.Address) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.Initialize(&_MerkleTreeStorage.TransactOpts, initialOwner) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_MerkleTreeStorage *MerkleTreeStorageTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _MerkleTreeStorage.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_MerkleTreeStorage *MerkleTreeStorageSession) RenounceOwnership() (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.RenounceOwnership(&_MerkleTreeStorage.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_MerkleTreeStorage *MerkleTreeStorageTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.RenounceOwnership(&_MerkleTreeStorage.TransactOpts) +} + +// StoreTree is a paid mutator transaction binding the contract method 0xbacdb394. +// +// Solidity: function storeTree(bytes32 merkleRoot, bytes[] leaves) returns(bytes32) +func (_MerkleTreeStorage *MerkleTreeStorageTransactor) StoreTree(opts *bind.TransactOpts, merkleRoot [32]byte, leaves [][32]byte) (*types.Transaction, error) { + return _MerkleTreeStorage.contract.Transact(opts, "storeTree", merkleRoot, leaves) +} + +// StoreTree is a paid mutator transaction binding the contract method 0xbacdb394. +// +// Solidity: function storeTree(bytes32 merkleRoot, bytes[] leaves) returns(bytes32) +func (_MerkleTreeStorage *MerkleTreeStorageSession) StoreTree(merkleRoot [32]byte, leaves [][32]byte) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.StoreTree(&_MerkleTreeStorage.TransactOpts, merkleRoot, leaves) +} + +// StoreTree is a paid mutator transaction binding the contract method 0xbacdb394. +// +// Solidity: function storeTree(bytes32 merkleRoot, bytes[] leaves) returns(bytes32) +func (_MerkleTreeStorage *MerkleTreeStorageTransactorSession) StoreTree(merkleRoot [32]byte, leaves [][32]byte) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.StoreTree(&_MerkleTreeStorage.TransactOpts, merkleRoot, leaves) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_MerkleTreeStorage *MerkleTreeStorageTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _MerkleTreeStorage.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_MerkleTreeStorage *MerkleTreeStorageSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.TransferOwnership(&_MerkleTreeStorage.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_MerkleTreeStorage *MerkleTreeStorageTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.TransferOwnership(&_MerkleTreeStorage.TransactOpts, newOwner) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_MerkleTreeStorage *MerkleTreeStorageTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _MerkleTreeStorage.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_MerkleTreeStorage *MerkleTreeStorageSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.UpgradeToAndCall(&_MerkleTreeStorage.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_MerkleTreeStorage *MerkleTreeStorageTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _MerkleTreeStorage.Contract.UpgradeToAndCall(&_MerkleTreeStorage.TransactOpts, newImplementation, data) +} + +// MerkleTreeStorageInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the MerkleTreeStorage contract. +type MerkleTreeStorageInitializedIterator struct { + Event *MerkleTreeStorageInitialized // 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 *MerkleTreeStorageInitializedIterator) 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(MerkleTreeStorageInitialized) + 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(MerkleTreeStorageInitialized) + 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 *MerkleTreeStorageInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MerkleTreeStorageInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MerkleTreeStorageInitialized represents a Initialized event raised by the MerkleTreeStorage contract. +type MerkleTreeStorageInitialized struct { + Version uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2. +// +// Solidity: event Initialized(uint64 version) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) FilterInitialized(opts *bind.FilterOpts) (*MerkleTreeStorageInitializedIterator, error) { + + logs, sub, err := _MerkleTreeStorage.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &MerkleTreeStorageInitializedIterator{contract: _MerkleTreeStorage.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2. +// +// Solidity: event Initialized(uint64 version) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *MerkleTreeStorageInitialized) (event.Subscription, error) { + + logs, sub, err := _MerkleTreeStorage.contract.WatchLogs(opts, "Initialized") + 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(MerkleTreeStorageInitialized) + if err := _MerkleTreeStorage.contract.UnpackLog(event, "Initialized", 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 +} + +// ParseInitialized is a log parse operation binding the contract event 0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2. +// +// Solidity: event Initialized(uint64 version) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) ParseInitialized(log types.Log) (*MerkleTreeStorageInitialized, error) { + event := new(MerkleTreeStorageInitialized) + if err := _MerkleTreeStorage.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MerkleTreeStorageOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the MerkleTreeStorage contract. +type MerkleTreeStorageOwnershipTransferredIterator struct { + Event *MerkleTreeStorageOwnershipTransferred // 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 *MerkleTreeStorageOwnershipTransferredIterator) 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(MerkleTreeStorageOwnershipTransferred) + 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(MerkleTreeStorageOwnershipTransferred) + 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 *MerkleTreeStorageOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MerkleTreeStorageOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MerkleTreeStorageOwnershipTransferred represents a OwnershipTransferred event raised by the MerkleTreeStorage contract. +type MerkleTreeStorageOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*MerkleTreeStorageOwnershipTransferredIterator, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _MerkleTreeStorage.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &MerkleTreeStorageOwnershipTransferredIterator{contract: _MerkleTreeStorage.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *MerkleTreeStorageOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _MerkleTreeStorage.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + 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(MerkleTreeStorageOwnershipTransferred) + if err := _MerkleTreeStorage.contract.UnpackLog(event, "OwnershipTransferred", 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 +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) ParseOwnershipTransferred(log types.Log) (*MerkleTreeStorageOwnershipTransferred, error) { + event := new(MerkleTreeStorageOwnershipTransferred) + if err := _MerkleTreeStorage.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MerkleTreeStorageTreeCreatedIterator is returned from FilterTreeCreated and is used to iterate over the raw logs and unpacked data for TreeCreated events raised by the MerkleTreeStorage contract. +type MerkleTreeStorageTreeCreatedIterator struct { + Event *MerkleTreeStorageTreeCreated // 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 *MerkleTreeStorageTreeCreatedIterator) 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(MerkleTreeStorageTreeCreated) + 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(MerkleTreeStorageTreeCreated) + 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 *MerkleTreeStorageTreeCreatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MerkleTreeStorageTreeCreatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MerkleTreeStorageTreeCreated represents a TreeCreated event raised by the MerkleTreeStorage contract. +type MerkleTreeStorageTreeCreated struct { + MerkleRoot [32]byte + Owner common.Address + Leaves [][]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTreeCreated is a free log retrieval operation binding the contract event 0xa56aae2dc75f499b69586042d0b4778cf971ee75f803dedb6b6a568502f7a047. +// +// Solidity: event TreeCreated(bytes32 indexed merkleRoot, address indexed owner, bytes[] leaves) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) FilterTreeCreated(opts *bind.FilterOpts, merkleRoot [][32]byte, owner []common.Address) (*MerkleTreeStorageTreeCreatedIterator, error) { + + var merkleRootRule []interface{} + for _, merkleRootItem := range merkleRoot { + merkleRootRule = append(merkleRootRule, merkleRootItem) + } + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + + logs, sub, err := _MerkleTreeStorage.contract.FilterLogs(opts, "TreeCreated", merkleRootRule, ownerRule) + if err != nil { + return nil, err + } + return &MerkleTreeStorageTreeCreatedIterator{contract: _MerkleTreeStorage.contract, event: "TreeCreated", logs: logs, sub: sub}, nil +} + +// WatchTreeCreated is a free log subscription operation binding the contract event 0xa56aae2dc75f499b69586042d0b4778cf971ee75f803dedb6b6a568502f7a047. +// +// Solidity: event TreeCreated(bytes32 indexed merkleRoot, address indexed owner, bytes[] leaves) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) WatchTreeCreated(opts *bind.WatchOpts, sink chan<- *MerkleTreeStorageTreeCreated, merkleRoot [][32]byte, owner []common.Address) (event.Subscription, error) { + + var merkleRootRule []interface{} + for _, merkleRootItem := range merkleRoot { + merkleRootRule = append(merkleRootRule, merkleRootItem) + } + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + + logs, sub, err := _MerkleTreeStorage.contract.WatchLogs(opts, "TreeCreated", merkleRootRule, ownerRule) + 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(MerkleTreeStorageTreeCreated) + if err := _MerkleTreeStorage.contract.UnpackLog(event, "TreeCreated", 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 +} + +// ParseTreeCreated is a log parse operation binding the contract event 0xa56aae2dc75f499b69586042d0b4778cf971ee75f803dedb6b6a568502f7a047. +// +// Solidity: event TreeCreated(bytes32 indexed merkleRoot, address indexed owner, bytes[] leaves) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) ParseTreeCreated(log types.Log) (*MerkleTreeStorageTreeCreated, error) { + event := new(MerkleTreeStorageTreeCreated) + if err := _MerkleTreeStorage.contract.UnpackLog(event, "TreeCreated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MerkleTreeStorageUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the MerkleTreeStorage contract. +type MerkleTreeStorageUpgradedIterator struct { + Event *MerkleTreeStorageUpgraded // 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 *MerkleTreeStorageUpgradedIterator) 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(MerkleTreeStorageUpgraded) + 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(MerkleTreeStorageUpgraded) + 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 *MerkleTreeStorageUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MerkleTreeStorageUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MerkleTreeStorageUpgraded represents a Upgraded event raised by the MerkleTreeStorage contract. +type MerkleTreeStorageUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*MerkleTreeStorageUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _MerkleTreeStorage.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &MerkleTreeStorageUpgradedIterator{contract: _MerkleTreeStorage.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *MerkleTreeStorageUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _MerkleTreeStorage.contract.WatchLogs(opts, "Upgraded", implementationRule) + 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(MerkleTreeStorageUpgraded) + if err := _MerkleTreeStorage.contract.UnpackLog(event, "Upgraded", 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 +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_MerkleTreeStorage *MerkleTreeStorageFilterer) ParseUpgraded(log types.Log) (*MerkleTreeStorageUpgraded, error) { + event := new(MerkleTreeStorageUpgraded) + if err := _MerkleTreeStorage.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/go.mod b/go.mod index ac053b2..a683eca 100644 --- a/go.mod +++ b/go.mod @@ -4,10 +4,11 @@ go 1.23.1 require ( github.com/CosmWasm/wasmd v0.54.0 - github.com/ethereum/go-ethereum v1.15.5 + github.com/cosmos/cosmos-sdk v0.50.11 + github.com/ethereum/go-ethereum v1.16.3 github.com/go-resty/resty/v2 v2.16.5 github.com/joho/godotenv v1.5.1 - google.golang.org/grpc v1.67.1 + google.golang.org/grpc v1.71.0 ) require ( @@ -27,8 +28,11 @@ require ( github.com/CosmWasm/wasmvm/v2 v2.2.1 // indirect github.com/DataDog/datadog-go v3.2.0+incompatible // indirect github.com/DataDog/zstd v1.5.5 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/StackExchange/wmi v1.2.1 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 // indirect + github.com/bits-and-blooms/bitset v1.20.0 // indirect github.com/bytedance/sonic v1.12.3 // indirect github.com/bytedance/sonic/loader v0.2.0 // indirect github.com/cenkalti/backoff/v4 v4.1.3 // indirect @@ -39,15 +43,16 @@ require ( github.com/cockroachdb/errors v1.11.3 // indirect github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce // indirect github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect - github.com/cockroachdb/pebble v1.1.2 // indirect + github.com/cockroachdb/pebble v1.1.5 // indirect github.com/cockroachdb/redact v1.1.5 // indirect github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect github.com/cometbft/cometbft v0.38.15 // indirect github.com/cometbft/cometbft-db v0.14.1 // indirect + github.com/consensys/bavard v0.1.31-0.20250406004941-2db259e4b582 // indirect + github.com/consensys/gnark-crypto v0.18.0 // indirect github.com/cosmos/btcutil v1.0.5 // indirect github.com/cosmos/cosmos-db v1.1.1 // indirect github.com/cosmos/cosmos-proto v1.0.0-beta.5 // indirect - github.com/cosmos/cosmos-sdk v0.50.11 // indirect github.com/cosmos/go-bip39 v1.0.0 // indirect github.com/cosmos/gogogateway v1.2.0 // indirect github.com/cosmos/gogoproto v1.7.0 // indirect @@ -56,8 +61,12 @@ require ( github.com/cosmos/ibc-go/v8 v8.4.0 // indirect github.com/cosmos/ics23/go v0.11.0 // indirect github.com/cosmos/ledger-cosmos-go v0.13.3 // indirect + github.com/crate-crypto/go-eth-kzg v1.3.0 // indirect + github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a // indirect + github.com/crate-crypto/go-kzg-4844 v1.1.0 // indirect github.com/danieljoos/wincred v1.1.2 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/deckarep/golang-set/v2 v2.6.0 // indirect github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 // indirect github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f // indirect github.com/dgraph-io/badger/v4 v4.2.0 // indirect @@ -66,6 +75,9 @@ require ( github.com/dustin/go-humanize v1.0.1 // indirect github.com/dvsekhvalnov/jose2go v1.6.0 // indirect github.com/emicklei/dot v1.6.2 // indirect + github.com/ethereum/c-kzg-4844 v1.0.0 // indirect + github.com/ethereum/c-kzg-4844/v2 v2.1.0 // indirect + github.com/ethereum/go-verkle v0.2.2 // indirect github.com/fatih/color v1.16.0 // indirect github.com/felixge/httpsnoop v1.0.4 // indirect github.com/fsnotify/fsnotify v1.7.0 // indirect @@ -73,16 +85,18 @@ require ( github.com/go-kit/kit v0.13.0 // indirect github.com/go-kit/log v0.2.1 // indirect github.com/go-logfmt/logfmt v0.6.0 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirect github.com/gogo/googleapis v1.4.1 // indirect github.com/gogo/protobuf v1.3.2 // indirect - github.com/golang/glog v1.2.2 // indirect + github.com/golang/glog v1.2.4 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/protobuf v1.5.4 // indirect github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect github.com/google/btree v1.1.3 // indirect github.com/google/flatbuffers v1.12.1 // indirect github.com/google/go-cmp v0.6.0 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/gorilla/handlers v1.5.2 // indirect github.com/gorilla/mux v1.8.1 // indirect github.com/gorilla/websocket v1.5.3 // indirect @@ -113,6 +127,7 @@ require ( github.com/mattn/go-isatty v0.0.20 // indirect github.com/mitchellh/go-testing-interface v1.14.1 // indirect github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/mmcloughlin/addchain v0.4.0 // indirect github.com/mtibben/percent v0.2.1 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a // indirect @@ -134,17 +149,21 @@ require ( github.com/sagikazarmark/slog-shim v0.1.0 // indirect github.com/sasha-s/go-deadlock v0.3.5 // indirect github.com/shamaton/msgpack/v2 v2.2.0 // indirect + github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect github.com/sourcegraph/conc v0.3.0 // indirect github.com/spf13/afero v1.11.0 // indirect github.com/spf13/cast v1.7.1 // indirect github.com/spf13/cobra v1.8.1 // indirect - github.com/spf13/pflag v1.0.5 // indirect + github.com/spf13/pflag v1.0.6 // indirect github.com/spf13/viper v1.19.0 // indirect github.com/stretchr/testify v1.10.0 // indirect github.com/subosito/gotenv v1.6.0 // indirect + github.com/supranational/blst v0.3.14 // indirect github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d // indirect github.com/tendermint/go-amino v0.16.0 // indirect github.com/tidwall/btree v1.7.0 // indirect + github.com/tklauser/go-sysconf v0.3.12 // indirect + github.com/tklauser/numcpus v0.6.1 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/zondax/hid v0.9.2 // indirect github.com/zondax/ledger-go v0.14.3 // indirect @@ -152,22 +171,23 @@ require ( go.opencensus.io v0.24.0 // indirect go.uber.org/multierr v1.11.0 // indirect golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect - golang.org/x/crypto v0.33.0 // indirect + golang.org/x/crypto v0.36.0 // indirect golang.org/x/exp v0.0.0-20240404231335-c0f41cb1a7a0 // indirect - golang.org/x/net v0.35.0 // indirect - golang.org/x/sync v0.11.0 // indirect - golang.org/x/sys v0.30.0 // indirect - golang.org/x/term v0.29.0 // indirect - golang.org/x/text v0.22.0 // indirect + golang.org/x/net v0.38.0 // indirect + golang.org/x/sync v0.12.0 // indirect + golang.org/x/sys v0.31.0 // indirect + golang.org/x/term v0.30.0 // indirect + golang.org/x/text v0.23.0 // indirect google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20240930140551-af27646dc61f // indirect - google.golang.org/protobuf v1.36.1 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250324211829-b45e905df463 // indirect + google.golang.org/protobuf v1.36.6 // indirect gopkg.in/ini.v1 v1.67.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect gotest.tools/v3 v3.5.1 // indirect nhooyr.io/websocket v1.8.6 // indirect pgregory.net/rapid v1.1.0 // indirect + rsc.io/tmplfunc v0.0.3 // indirect sigs.k8s.io/yaml v1.4.0 // indirect ) diff --git a/go.sum b/go.sum index bcdba47..98829e7 100644 --- a/go.sum +++ b/go.sum @@ -3,8 +3,8 @@ cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT cloud.google.com/go v0.112.1 h1:uJSeirPke5UNZHIb4SxfZklVSiWWVqW4oXlETwZziwM= cloud.google.com/go v0.112.1/go.mod h1:+Vbu+Y1UU+I1rjmzeMOb/8RfkKJK2Gyxi1X6jJCZLo4= cloud.google.com/go/compute v1.24.0 h1:phWcR2eWzRJaL/kOiJwfFsPs4BaKq1j6vnpZrc1YlVg= -cloud.google.com/go/compute/metadata v0.5.0 h1:Zr0eK8JbFv6+Wi4ilXAR8FJ3wyNdpxHKJNPos6LTZOY= -cloud.google.com/go/compute/metadata v0.5.0/go.mod h1:aHnloV2TPI38yx4s9+wAZhHykWvVCfu7hQbF+9CWoiY= +cloud.google.com/go/compute/metadata v0.6.0 h1:A6hENjEsCDtC1k8byVsgwvVcioamEHvZ4j01OwKxG9I= +cloud.google.com/go/compute/metadata v0.6.0/go.mod h1:FjyFAW1MW0C203CEOMDTu3Dk1FlqW3Rga40jzHL4hfg= cloud.google.com/go/iam v1.1.6 h1:bEa06k05IO4f4uJonbB5iAgKTPpABy1ayxaIZV/GHVc= cloud.google.com/go/iam v1.1.6/go.mod h1:O0zxdPeGBoFdWW3HWmBxJsk0pfvNM/p/qa82rWOGTwI= cloud.google.com/go/storage v1.38.0 h1:Az68ZRGlnNTpIBbLjSMIV2BDcwwXYlRlQzis0llkpJg= @@ -55,8 +55,14 @@ github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3 github.com/DataDog/zstd v1.5.5 h1:oWf5W7GtOLgp6bciQYDmhHHjdhYkALu6S/5Ni9ZgSvQ= github.com/DataDog/zstd v1.5.5/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= +github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= +github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= +github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI= +github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI= github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE= github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c= @@ -89,6 +95,8 @@ github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 h1:41iFGWnSlI2 github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bits-and-blooms/bitset v1.17.0 h1:1X2TS7aHz1ELcC0yU1y2stUs/0ig5oMU6STFZGrhvHI= github.com/bits-and-blooms/bitset v1.17.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/bits-and-blooms/bitset v1.20.0 h1:2F+rfL86jE2d/bmw7OhqUg2Sj/1rURkBn3MdfoPyRVU= +github.com/bits-and-blooms/bitset v1.20.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= github.com/btcsuite/btcd/btcec/v2 v2.3.4 h1:3EJjcN70HCu/mwqlUsGK8GcNVyLVxFDlWurTXGPFfiQ= github.com/btcsuite/btcd/btcec/v2 v2.3.4/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= github.com/btcsuite/btcd/btcutil v1.1.6 h1:zFL2+c3Lb9gEgqKNzowKUPQNb8jV7v5Oaodi/AYFd6c= @@ -106,6 +114,8 @@ github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInq github.com/cenkalti/backoff/v4 v4.1.3 h1:cFAlzYUlVYDysBEH2T5hyJZMh3+5+WCBvSnK6Q8UtC4= github.com/cenkalti/backoff/v4 v4.1.3/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +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.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= @@ -144,6 +154,7 @@ github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZe github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= github.com/cockroachdb/pebble v1.1.2 h1:CUh2IPtR4swHlEj48Rhfzw6l/d0qA31fItcIszQVIsA= github.com/cockroachdb/pebble v1.1.2/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU= +github.com/cockroachdb/pebble v1.1.5/go.mod h1:17wO9el1YEigxkP/YtV8NtCivQDgoCyBg5c4VR/eOWo= github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= @@ -153,6 +164,14 @@ github.com/cometbft/cometbft v0.38.15 h1:5veFd8k1uXM27PBg9sMO3hAfRJ3vbh4OmmLf6cV github.com/cometbft/cometbft v0.38.15/go.mod h1:+wh6ap6xctVG+JOHwbl8pPKZ0GeqdPYqISu7F4b43cQ= github.com/cometbft/cometbft-db v0.14.1 h1:SxoamPghqICBAIcGpleHbmoPqy+crij/++eZz3DlerQ= github.com/cometbft/cometbft-db v0.14.1/go.mod h1:KHP1YghilyGV/xjD5DP3+2hyigWx0WTp9X+0Gnx0RxQ= +github.com/consensys/bavard v0.1.22 h1:Uw2CGvbXSZWhqK59X0VG/zOjpTFuOMcPLStrp1ihI0A= +github.com/consensys/bavard v0.1.22/go.mod h1:k/zVjHHC4B+PQy1Pg7fgvG3ALicQw540Crag8qx+dZs= +github.com/consensys/bavard v0.1.31-0.20250406004941-2db259e4b582 h1:dTlIwEdFQmldzFf5F6bbTcYWhvnAgZai2g8eq3Wwxqg= +github.com/consensys/bavard v0.1.31-0.20250406004941-2db259e4b582/go.mod h1:k/zVjHHC4B+PQy1Pg7fgvG3ALicQw540Crag8qx+dZs= +github.com/consensys/gnark-crypto v0.14.0 h1:DDBdl4HaBtdQsq/wfMwJvZNE80sHidrK3Nfrefatm0E= +github.com/consensys/gnark-crypto v0.14.0/go.mod h1:CU4UijNPsHawiVGNxe9co07FkzCeWHHrb1li/n1XoU0= +github.com/consensys/gnark-crypto v0.18.0 h1:vIye/FqI50VeAr0B3dx+YjeIvmc3LWz4yEfbWBpTUf0= +github.com/consensys/gnark-crypto v0.18.0/go.mod h1:L3mXGFTe1ZN+RSJ+CLjUt9x7PNdx8ubaYfDROyp2Z8c= github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= @@ -184,6 +203,14 @@ github.com/cosmos/ledger-cosmos-go v0.13.3 h1:7ehuBGuyIytsXbd4MP43mLeoN2LTOEnk5n github.com/cosmos/ledger-cosmos-go v0.13.3/go.mod h1:HENcEP+VtahZFw38HZ3+LS3Iv5XV6svsnkk9vdJtLr8= github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/cpuguy83/go-md2man/v2 v2.0.5 h1:ZtcqGrnekaHpVLArFSe4HK5DoKx1T0rq2DwVB0alcyc= +github.com/cpuguy83/go-md2man/v2 v2.0.5/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-eth-kzg v1.3.0 h1:05GrhASN9kDAidaFJOda6A4BEvgvuXbazXg/0E3OOdI= +github.com/crate-crypto/go-eth-kzg v1.3.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI= +github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a h1:W8mUrRp6NOVl3J+MYp5kPMoUZPp7aOYHtaua31lwRHg= +github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a/go.mod h1:sTwzHBvIzm2RfVCGNEBZgRyjwK40bVoun3ZnGOCafNM= +github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4= +github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks= github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/danieljoos/wincred v1.1.2 h1:QLdCxFs1/Yl4zduvBdcHB8goaYk9RARS2SgLLRuAyr0= @@ -192,6 +219,8 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs 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.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM= +github.com/deckarep/golang-set/v2 v2.6.0/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= @@ -228,8 +257,16 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA= +github.com/ethereum/c-kzg-4844 v1.0.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/c-kzg-4844/v2 v2.1.0 h1:gQropX9YFBhl3g4HYhwE70zq3IHFRgbbNPw0Shwzf5w= +github.com/ethereum/c-kzg-4844/v2 v2.1.0/go.mod h1:TC48kOKjJKPbN7C++qIgt0TJzZ70QznYR7Ob+WXl57E= github.com/ethereum/go-ethereum v1.15.5 h1:Fo2TbBWC61lWVkFw9tsMoHCNX1ndpuaQBRJ8H6xLUPo= github.com/ethereum/go-ethereum v1.15.5/go.mod h1:1LG2LnMOx2yPRHR/S+xuipXH29vPr6BIH6GElD8N/fo= +github.com/ethereum/go-ethereum v1.16.3 h1:nDoBSrmsrPbrDIVLTkDQCy1U9KdHN+F2PzvMbDoS42Q= +github.com/ethereum/go-ethereum v1.16.3/go.mod h1:Lrsc6bt9Gm9RyvhfFK53vboCia8kpF9nv+2Ukntnl+8= +github.com/ethereum/go-verkle v0.2.2 h1:I2W0WjnrFUIzzVPwm8ykY+7pL2d4VhlsePn4j7cnFk8= +github.com/ethereum/go-verkle v0.2.2/go.mod h1:M3b90YRnzqKyyzBEWJGqj8Qff4IDeXnzFw0P9bFw3uk= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= @@ -271,10 +308,13 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4= github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= -github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= -github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +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.5/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/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= github.com/go-playground/locales v0.14.0 h1:u50s323jtVGugKlcYeyzC0etD1HifMjqmJqb8WugfUU= @@ -303,6 +343,8 @@ github.com/goccy/go-json v0.10.4/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PU github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+Hoeu/iUR3ruzNvZ+yQfO03a0= github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= +github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= github.com/gogo/googleapis v1.4.1-0.20201022092350-68b0159b7869/go.mod h1:5YRNX2z1oM5gXdAkurHa942MDgEJyk02w4OecKY87+c= github.com/gogo/googleapis v1.4.1 h1:1Yx4Myt7BxzvUr5ldGSbwYiZG6t9wGBZ+8/fX3Wvtq0= @@ -313,9 +355,12 @@ github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zV github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt/v4 v4.5.1 h1:JdqV9zKUdtaa9gdPlywC3aeoEsR681PlKC+4F5gQgeo= +github.com/golang-jwt/jwt/v4 v4.5.1/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/glog v1.2.2 h1:1+mZ9upx1Dh6FmUTFR1naJ77miKiXgALjWOZ3NVFPmY= -github.com/golang/glog v1.2.2/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w= +github.com/golang/glog v1.2.4 h1:CNNw5U8lSiiBk7druxtSHHTsRWcxKoac6kZKm2peBBc= +github.com/golang/glog v1.2.4/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -373,6 +418,7 @@ github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLe github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/s2a-go v0.1.7 h1:60BLSyTrOV4/haCDW4zb1guZItoSq8foHCXrAnjBo/o= github.com/google/s2a-go v0.1.7/go.mod h1:50CgR4k1jNlWBu4UfS4AcfhVe1r6pdZPygJ3R8F0Qdw= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= @@ -406,6 +452,8 @@ github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NM github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE= github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= github.com/hashicorp/errwrap v1.0.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-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= @@ -453,6 +501,10 @@ github.com/hashicorp/yamux v0.1.1 h1:yrQxtgseBDrq9Y652vSRDvsKCJKOUD+GzTS4Y0Y8pvE github.com/hashicorp/yamux v0.1.1/go.mod h1:CtWFDAQgb7dxtzFs4tWbplKIe2jSi3+5vKbgIO0SLnQ= github.com/hdevalence/ed25519consensus v0.1.0 h1:jtBwzzcHuTmFrQN6xQZn6CQEO/V9f7HsjsjeEZ6auqU= github.com/hdevalence/ed25519consensus v0.1.0/go.mod h1:w3BHWjwJbFU29IRHL1Iqkw3sus+7FctEyM4RqDxYNzo= +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.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA= github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= @@ -461,6 +513,8 @@ github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0Jr github.com/huandu/skiplist v1.2.0 h1:gox56QD77HzSC0w+Ws3MH3iie755GBJU1OER3h5VsYw= github.com/huandu/skiplist v1.2.0/go.mod h1:7v3iFjLcSAzO4fN5B8dvebvo/qsfumiLiDXMrPiHF9w= github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI= github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= @@ -470,6 +524,8 @@ github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANyt 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/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= +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/jhump/protoreflect v1.15.3 h1:6SFRuqU45u9hIZPJAoZ8c28T3nK64BNdp9w6jFonzls= github.com/jhump/protoreflect v1.15.3/go.mod h1:4ORHmSBmlCW8fh3xHmJMGyul1zNqZK4Elxc8qKP+p1k= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= @@ -512,6 +568,10 @@ 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/leanovate/gopter v0.2.11 h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4= +github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f7Xvpt0S9c= github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w= github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY= @@ -540,6 +600,8 @@ github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D 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.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +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/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= github.com/minio/highwayhash v1.0.3 h1:kbnuUMoHYyVl7szWjSxJnxw11k2U709jqFPPmIUyD6Q= @@ -557,6 +619,11 @@ github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:F github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= 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/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= @@ -590,6 +657,8 @@ github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQ github.com/oklog/run v1.1.0 h1:GEenZ1cK0+q0+wsJew9qUg/DyD8k3JzYsZAi5gYi2mA= github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DVU= github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= +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.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= @@ -629,6 +698,16 @@ github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= +github.com/pion/dtls/v2 v2.2.7 h1:cSUBsETxepsCSFSxC3mc/aDo14qQLMSL+O6IjG28yV8= +github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s= +github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY= +github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms= +github.com/pion/stun/v2 v2.0.0 h1:A5+wXKLAypxQri59+tmQKVs7+l6mMM+3d+eER9ifRU0= +github.com/pion/stun/v2 v2.0.0/go.mod h1:22qRSh08fSEttYUmJZGlriq9+03jtVmXNODgLccj8GQ= +github.com/pion/transport/v2 v2.2.1 h1:7qYnCBlpgSJNYMbLCKuSY9KbQdBFoETvPNETv0y4N7c= +github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g= +github.com/pion/transport/v3 v3.0.1 h1:gDTlPJwROfSfz6QfSi0ZmeCSkFcnWWiiR9ES0ouANiM= +github.com/pion/transport/v3 v3.0.1/go.mod h1:UY7kiITrlMv7/IKgd5eTUcaahZx5oUN3l9SzK5f5xE0= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= @@ -674,6 +753,8 @@ github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoG github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM= github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= @@ -687,6 +768,7 @@ github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8= github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +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/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= @@ -699,6 +781,8 @@ github.com/sasha-s/go-deadlock v0.3.5/go.mod h1:bugP6EGbdGYObIlx7pUZtWqlvo8k9H6v github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= github.com/shamaton/msgpack/v2 v2.2.0 h1:IP1m01pHwCrMa6ZccP9B3bqxEMKMSmMVAVKk54g3L/Y= github.com/shamaton/msgpack/v2 v2.2.0/go.mod h1:6khjYnkx73f7VQU7wjcFS9DFjs+59naVWJv1TB7qdOI= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= @@ -720,6 +804,7 @@ github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3k github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= 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/pflag v1.0.6/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/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= @@ -747,12 +832,18 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= 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.14 h1:xNMoHRJOTwMn63ip6qoWJ2Ymgvj7E2b9jY2FAwY+qRo= +github.com/supranational/blst v0.3.14/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d h1:vfofYNRScrDdvS342BElfbETmL1Aiz3i2t0zfRj16Hs= github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d/go.mod h1:RRCYJbIwD5jmqPI9XoAFR0OcDxqUctll6zUj/+B4S48= github.com/tendermint/go-amino v0.16.0 h1:GyhmgQKvqF82e2oZeuMSp9JTN0N09emoSZlb2lyGa2E= github.com/tendermint/go-amino v0.16.0/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME= github.com/tidwall/btree v1.7.0 h1:L1fkJH/AuEh5zBnnBbmTwQ5Lt+bRJ5A8EWecslvo9iI= github.com/tidwall/btree v1.7.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EUQ2cKY= +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/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= @@ -765,8 +856,13 @@ github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZ github.com/ulikunitz/xz v0.5.11 h1:kpFauv27b6ynzBNT/Xy+1k+fK4WswhN/6PN5WhFAGw8= github.com/ulikunitz/xz v0.5.11/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= +github.com/urfave/cli v1.22.1 h1:+mkCCcOFKPnCmVYVcURKps1Xe+3zP90gSYGNfRkjoIY= github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= +github.com/urfave/cli/v2 v2.27.5 h1:WoHEJLdsXr6dDWoJgMq/CboDmyY/8HMMH1fTECbih+w= +github.com/urfave/cli/v2 v2.27.5/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= +github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4= +github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/zondax/hid v0.9.2 h1:WCJFnEDMiqGF64nlZz28E9qLVZ0KSJ7xpc5DLEyma2U= @@ -782,16 +878,22 @@ go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= +go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= +go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 h1:4Pp6oUg3+e/6M4C0A/3kJ2VYa++dsWVTtGgLVj5xtHg= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0/go.mod h1:Mjt1i1INqiaoZOMGR1RIUJN+i3ChKoFRqzrRQhlkbs0= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= -go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo= -go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo= -go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI= -go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco= -go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI= -go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU= +go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY= +go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI= +go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ= +go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE= +go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A= +go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU= +go.opentelemetry.io/otel/sdk/metric v1.34.0 h1:5CeK9ujjbFVL5c1PhLuStg1wxA7vQv7ce1EK0Gyvahk= +go.opentelemetry.io/otel/sdk/metric v1.34.0/go.mod h1:jQ/r8Ze28zRKoNRdkjCZxfs6YvBTG1+YIqyFVFYec5w= +go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k= +go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= @@ -817,8 +919,8 @@ golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8U 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-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus= -golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M= +golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= +golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= @@ -865,13 +967,15 @@ golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8= -golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk= +golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c= +golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8= +golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8= +golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.23.0 h1:PbgcYx2W7i4LvjJWEbf0ngHV6qJYr86PkAV3bXdLEbs= -golang.org/x/oauth2 v0.23.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= +golang.org/x/oauth2 v0.25.0 h1:CY4y7XT9v0cRI9oupztF8AgiIu99L/ksR/Xp/6jrZ70= +golang.org/x/oauth2 v0.25.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -879,8 +983,8 @@ golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJ 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.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w= -golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw= +golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -897,6 +1001,7 @@ golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/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-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -931,22 +1036,25 @@ golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/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-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.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.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc= -golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik= +golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= 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.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU= -golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s= +golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y= +golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g= 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.5/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.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM= -golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY= +golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= +golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY= @@ -995,10 +1103,10 @@ google.golang.org/genproto v0.0.0-20210126160654-44e461bb6506/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20220314164441-57ef72a4c106/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de h1:F6qOa9AZTYJXOUEr4jDysRDLrm4PHePlge4v4TGAlxY= google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de/go.mod h1:VUhTRKeHn9wwcdrk73nvdC9gF178Tzhmt/qyaFcPLSo= -google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 h1:wKguEg1hsxI2/L3hUYrpo1RVi48K+uTyzKqprwLXsb8= -google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142/go.mod h1:d6be+8HhtEtucleCbxpPW9PA9XwISACu8nvpPqF0BVo= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240930140551-af27646dc61f h1:cUMEy+8oS78BWIH9OWazBkzbr090Od9tWBNtZHkOhf0= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240930140551-af27646dc61f/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422 h1:GVIKPyP/kLIyVOgOnTwFOrvQaQUzOzGMCxgFUOEmm24= +google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422/go.mod h1:b6h1vNKhxaSoEI+5jc3PJUCustfli/mRab7295pY7rw= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250324211829-b45e905df463 h1:e0AIkUUhxyBKh6ssZNrAMeqhA7RKUj42346d1y02i2g= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250324211829-b45e905df463/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM= @@ -1017,8 +1125,8 @@ google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= -google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E= -google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA= +google.golang.org/grpc v1.71.0 h1:kF77BGdPTQ4/JZWMlb9VpJ5pa25aqvVqogsxNHHdeBg= +google.golang.org/grpc v1.71.0/go.mod h1:H0GRtasmQOh9LkFoCPDu3ZrwUtD1YGE+b2vYBYd/8Ec= 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= @@ -1033,8 +1141,8 @@ google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp0 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= -google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk= -google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= 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= @@ -1048,6 +1156,8 @@ gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMy gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o= 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.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= +gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= 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= @@ -1077,6 +1187,8 @@ nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0 nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50= pgregory.net/rapid v1.1.0 h1:CMa0sjHSru3puNx+J0MIAuiiEV4N0qj8/cMWGBBCsjw= pgregory.net/rapid v1.1.0/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E= sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= diff --git a/main.go b/main.go index 2b947d3..9c62cb9 100644 --- a/main.go +++ b/main.go @@ -10,13 +10,32 @@ import ( "syscall" "time" + "github.com/Layer-Edge/light-node/clients" "github.com/Layer-Edge/light-node/node" "github.com/Layer-Edge/light-node/utils" "github.com/joho/godotenv" ) +/* + superProofClient := clients.MerkleTreeClient{} + superProofContractAddress := utils.GetEnv("SUPER_PROOF_CONTRACT_ADDRESS", "0x7f9ebd5da0829bdb6cdff45bba0d68c0cae39364") + err := superProofClient.Init(superProofContractAddress) + if err != nil { + log.Fatalf("failed to initialize super proof client: %v", err) + } + defer superProofClient.Close() +*/ + func Worker(ctx context.Context, wg *sync.WaitGroup, id int) { defer wg.Done() + + merkleTreeClient := clients.MerkleTreeClient{} + merkleTreeStorageContractAddress := utils.GetEnv("MERKLE_TREE_STORAGE_CONTRACT_ADDRESS", "0x57bEBD1b51dF9F221F763a708591c1E72D2379D6") + err := merkleTreeClient.Init(merkleTreeStorageContractAddress) + if err != nil { + log.Fatalf("failed to initialize cosmos query client: %v", err) + } + defer merkleTreeClient.Close() for { select { case <-ctx.Done(): @@ -24,7 +43,31 @@ func Worker(ctx context.Context, wg *sync.WaitGroup, id int) { return default: fmt.Printf("Worker %d is running...\n", id) - node.CollectSampleAndVerify() + node.CollectSampleAndVerify(&merkleTreeClient, "base proof") + time.Sleep(5 * time.Second) + } + } +} + +func SuperProofWorker(ctx context.Context, wg *sync.WaitGroup, id int) { + defer wg.Done() + + superProofClient := clients.MerkleTreeClient{} + superProofContractAddress := utils.GetEnv("SUPER_PROOF_CONTRACT_ADDRESS", "0x7f9ebd5da0829bdb6cdff45bba0d68c0cae39364") + err := superProofClient.Init(superProofContractAddress) + if err != nil { + log.Fatalf("failed to initialize super proof client: %v", err) + } + defer superProofClient.Close() + + for { + select { + case <-ctx.Done(): + fmt.Printf("Super Proof Worker %d is shutting down\n", id) + return + default: + fmt.Printf("Super Proof Worker %d is running...\n", id) + node.CollectSampleAndVerify(&superProofClient, "super proof") time.Sleep(5 * time.Second) } } @@ -51,14 +94,19 @@ func main() { signal.Notify(signalChan, syscall.SIGABRT, syscall.SIGTERM) - wg.Add(1) + log.Printf("Starting 2 worker(s)...") + + wg.Add(2) + go Worker(ctx, &wg, 1) + go SuperProofWorker(ctx, &wg, 1) + <-signalChan fmt.Println("\nReceived interrupt signal. Shutting down gracefully...") cancel() wg.Wait() - fmt.Println("Worker has shut down. Exiting..") + fmt.Println("All workers have shut down. Exiting..") } diff --git a/node/verifier.go b/node/verifier.go index 15acdbb..eec2ec3 100644 --- a/node/verifier.go +++ b/node/verifier.go @@ -89,21 +89,14 @@ func verifyProofs(data []string, proof Proof) (*string, *string, error) { return &resp.Receipt, &resp.Root, nil } -func CollectSampleAndVerify() { - cosmosQueryClient := clients.CosmosQueryClient{} - err := cosmosQueryClient.Init() +func CollectSampleAndVerify(merkleTreeClient *clients.MerkleTreeClient, clientType string) { + treeIds, err := merkleTreeClient.GetAllRoots() if err != nil { - log.Fatalf("failed to initialize cosmos query client: %v", err) - } - defer cosmosQueryClient.Close() - - treeIds, err := cosmosQueryClient.ListMerkleTreeIds() - if err != nil { - log.Fatalf("failed to fetch tree ids: %v", err) + log.Fatalf("failed to fetch %s tree ids: %v", clientType, err) } if len(treeIds) == 0 { - log.Println("No trees available") + log.Printf("No trees available for %s", clientType) return } @@ -112,18 +105,18 @@ func CollectSampleAndVerify() { for _, treeId := range treeIds { // Skip trees that are sleeping stateMutex.Lock() - state, exists := treeStates[treeId] + state, exists := treeStates[treeId.Hex()] if exists && time.Now().Before(state.SleepUntil) { - log.Printf("Tree %s is sleeping until %s, skipping", treeId, state.SleepUntil.Format(time.RFC3339)) + log.Printf("%s Tree %s is sleeping until %s, skipping", clientType, treeId, state.SleepUntil.Format(time.RFC3339)) stateMutex.Unlock() continue } stateMutex.Unlock() // Get tree data - tree, err := cosmosQueryClient.GetMerkleTreeData(treeId) + tree, err := merkleTreeClient.GetTreeInfo(treeId) if err != nil { - log.Printf("failed to fetch tree data for %s: %v", treeId, err) + log.Printf("failed to fetch %s tree data for %s: %v", clientType, treeId, err) continue } @@ -131,12 +124,12 @@ func CollectSampleAndVerify() { stateMutex.Lock() if !exists { // First time seeing this tree - treeStates[treeId] = &TreeState{ - LastRoot: tree.Root, + treeStates[treeId.Hex()] = &TreeState{ + LastRoot: tree.Root.Hex(), ConsecutiveSame: 0, } stateMutex.Unlock() - } else if state.LastRoot == tree.Root { + } else if state.LastRoot == tree.Root.Hex() { // Root hasn't changed - increment counter and potentially sleep state.ConsecutiveSame++ @@ -144,15 +137,15 @@ func CollectSampleAndVerify() { // After 3 consecutive same roots, put the tree to sleep for 5 minutes sleepDuration := 5 * time.Minute state.SleepUntil = time.Now().Add(sleepDuration) - log.Printf("Tree %s has had the same root %s for %d checks, putting to sleep for %v", - treeId, tree.Root, state.ConsecutiveSame, sleepDuration) + log.Printf("%s Tree %s has had the same root %s for %d checks, putting to sleep for %v", + clientType, treeId, tree.Root, state.ConsecutiveSame, sleepDuration) stateMutex.Unlock() continue } stateMutex.Unlock() } else { // Root has changed - reset counter - state.LastRoot = tree.Root + state.LastRoot = tree.Root.Hex() state.ConsecutiveSame = 0 stateMutex.Unlock() } @@ -165,14 +158,14 @@ func CollectSampleAndVerify() { proof, err := proveProof(tree.Leaves, sample) if err != nil { - log.Printf("failed to prove sample for tree %s: %v", treeId, err) + log.Printf("failed to prove sample for %s tree %s: %v", clientType, treeId.Hex(), err) // Continue to the next tree if proving fails continue } receipt, rootHash, err := verifyProofs(tree.Leaves, *proof) if err != nil { - log.Printf("failed to verify sample for tree %s: %v", treeId, err) + log.Printf("failed to verify sample for %s tree %s: %v", clientType, treeId.Hex(), err) // Continue to the next tree if verification fails continue } @@ -197,13 +190,13 @@ func CollectSampleAndVerify() { // Continue to the next tree if submission fails continue } else { - log.Printf("Successfully submitted verified proof for tree %s", treeId) + log.Printf("Successfully submitted verified proof for tree %s", treeId.Hex()) verificationSuccessful = true } // Update the tree state with the verified root stateMutex.Lock() - if state, exists := treeStates[treeId]; exists { + if state, exists := treeStates[treeId.Hex()]; exists { if state.LastRoot != *rootHash { state.LastRoot = *rootHash state.ConsecutiveSame = 0 @@ -211,9 +204,9 @@ func CollectSampleAndVerify() { } stateMutex.Unlock() - log.Printf("Tree %s - Sample Data %v verified with receipt %v\n", treeId, sample, *receipt) + log.Printf("%s Tree %s - Sample Data %v verified with receipt %v\n", clientType, treeId.Hex(), sample, *receipt) } else { - log.Printf("Tree %s - Verification failed: missing receipt or root hash", treeId) + log.Printf("%s Tree %s - Verification failed: missing receipt or root hash", clientType, treeId.Hex()) continue } @@ -225,7 +218,7 @@ func CollectSampleAndVerify() { } if !activeTreeFound { - log.Println("No active trees available for verification or all verification attempts failed") + log.Printf("No active trees available for %s verification or all verification attempts failed", clientType) } } diff --git a/risc0-merkle-service/.gitignore b/risc0-merkle-service/.gitignore deleted file mode 100644 index c315829..0000000 --- a/risc0-merkle-service/.gitignore +++ /dev/null @@ -1,6 +0,0 @@ -.DS_Store -Cargo.lock -methods/guest/Cargo.lock -target/ - -.env \ No newline at end of file diff --git a/risc0-merkle-service/Cargo.toml b/risc0-merkle-service/Cargo.toml deleted file mode 100644 index 63b3854..0000000 --- a/risc0-merkle-service/Cargo.toml +++ /dev/null @@ -1,11 +0,0 @@ -[workspace] -resolver = "2" -members = ["host", "methods"] - -# Always optimize; building and running the guest takes much longer without optimization. -[profile.dev] -opt-level = 3 - -[profile.release] -debug = 1 -lto = true diff --git a/risc0-merkle-service/cli/Cargo.toml b/risc0-merkle-service/cli/Cargo.toml deleted file mode 100644 index 10f54c0..0000000 --- a/risc0-merkle-service/cli/Cargo.toml +++ /dev/null @@ -1,14 +0,0 @@ -[package] -name = "cli" -version = "0.1.0" -edition = "2021" - -[dependencies] -methods = { path = "../methods" } -clap = { version = "4.4", features = ["derive"] } -reqwest = { version = "0.11", features = ["json"] } -tokio = { version = "1.0", features = ["full"] } -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -sha2 = "0.10" -hex = "0.4" \ No newline at end of file diff --git a/risc0-merkle-service/cli/src/main.rs b/risc0-merkle-service/cli/src/main.rs deleted file mode 100644 index 372e54e..0000000 --- a/risc0-merkle-service/cli/src/main.rs +++ /dev/null @@ -1,142 +0,0 @@ -use clap::{Parser, Subcommand}; -use reqwest::Client; -use serde::{Deserialize, Serialize}; -use std::error::Error; - -#[derive(Parser)] -#[command(author, version, about, long_about = None)] -struct Cli { - #[command(subcommand)] - command: Commands, -} - -#[derive(Subcommand)] -enum Commands { - Insert { - /// Data items to insert (multiple values allowed) - #[arg(required = true)] - data: Vec, - }, - Prove { - /// Data items to build the tree - #[arg(required = true)] - data: Vec, - /// Value to generate proof for - #[arg(required = true)] - value: String, - }, - Verify { - /// Data items in the tree - #[arg(required = true)] - data: Vec, - /// Value to verify - #[arg(required = true)] - value: String, - /// Proof path (comma-separated pairs of hash:side, where side is 'left' or 'right') - #[arg(required = true)] - proof: String, - }, -} - -#[derive(Serialize, Deserialize)] -struct Request { - operation: String, - data: Vec, - proof_request: Option, - proof: Option, -} - -#[derive(Serialize, Deserialize, Debug)] -struct MerkleProof { - leaf_value: String, - proof_path: Vec<(String, bool)>, -} - -#[derive(Deserialize, Debug)] -struct Response { - root: Option, - proof: Option, - verified: Option, -} - -async fn send_request(request: Request) -> Result> { - let client = Client::new(); - let response = client - .post("http://localhost:8080/process") - .json(&request) - .send() - .await? - .json::() - .await?; - Ok(response) -} - -#[tokio::main] -async fn main() -> Result<(), Box> { - let cli = Cli::parse(); - - match cli.command { - Commands::Insert { data } => { - let request = Request { - operation: "insert".to_string(), - data, - proof_request: None, - proof: None, - }; - - let response = send_request(request).await?; - println!("Root hash: {}", response.root.unwrap_or_default()); - } - Commands::Prove { data, value } => { - let request = Request { - operation: "prove".to_string(), - data, - proof_request: Some(value), - proof: None, - }; - - let response = send_request(request).await?; - if let Some(proof) = response.proof { - println!("Merkle Proof:"); - println!("Leaf value: {}", proof.leaf_value); - println!("Proof path:"); - for (hash, is_right) in proof.proof_path { - println!(" Hash: {}, Side: {}", hash, if is_right { "right" } else { "left" }); - } - println!("Root hash: {}", response.root.unwrap_or_default()); - } else { - println!("No proof generated"); - } - } - Commands::Verify { data, value, proof } => { - // Parse proof string - let proof_pairs: Vec<&str> = proof.split(',').collect(); - let mut proof_path = Vec::new(); - - for pair in proof_pairs { - let parts: Vec<&str> = pair.split(':').collect(); - if parts.len() == 2 { - proof_path.push(( - parts[0].to_string(), - parts[1] == "right", - )); - } - } - - let request = Request { - operation: "verify".to_string(), - data, - proof_request: None, - proof: Some(MerkleProof { - leaf_value: value, - proof_path, - }), - }; - - let response = send_request(request).await?; - println!("Verification result: {}", response.verified.unwrap_or(false)); - } - } - - Ok(()) -} \ No newline at end of file diff --git a/risc0-merkle-service/host/Cargo.toml b/risc0-merkle-service/host/Cargo.toml deleted file mode 100644 index a562521..0000000 --- a/risc0-merkle-service/host/Cargo.toml +++ /dev/null @@ -1,17 +0,0 @@ -[package] -name = "host" -version = "0.1.0" -edition = "2021" - -[dependencies] -methods = { path = "../methods" } -risc0-zkvm = { version = "1.2.0" } -tracing-subscriber = { version = "0.3", features = ["env-filter"] } -serde = "1.0" -serde_json = "1.0" -actix-web = "4.0" -base64 = "0.13" -bincode = "1.3" -sha2 = "0.10" -hex = "0.4" -dotenv = "0.15.0" diff --git a/risc0-merkle-service/host/src/main.rs b/risc0-merkle-service/host/src/main.rs deleted file mode 100644 index baeea16..0000000 --- a/risc0-merkle-service/host/src/main.rs +++ /dev/null @@ -1,115 +0,0 @@ -use actix_web::{web, App, HttpServer, HttpResponse}; -use methods::{GUEST_ELF, GUEST_ID}; -use risc0_zkvm::{default_prover, ExecutorEnv, VerifierContext, ProverOpts}; -use serde::{Deserialize, Serialize}; -use std::fmt; - -#[derive(Debug)] -struct ProcessError(String); - -impl fmt::Display for ProcessError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.0) - } -} - -impl std::error::Error for ProcessError {} - -#[derive(Serialize, Deserialize)] -struct Request { - operation: String, - data: Vec, - proof_request: Option, - proof: Option, -} - -#[derive(Serialize, Deserialize)] -struct MerkleProof { - leaf_value: String, - proof_path: Vec<(String, bool)>, -} - -#[derive(Serialize, Deserialize)] -struct Response { - root: Option, - proof: Option, - verified: Option, - receipt: Option, -} - -async fn process(req: web::Json) -> HttpResponse { - let request_data = req.0; - - let result = web::block(move || { - println!("Starting request processing..."); - println!("Operation: {}", request_data.operation); - println!("Input data: {:?}", request_data.data); - - let env = ExecutorEnv::builder() - .write(&request_data) - .unwrap() - .build() - .map_err(|e| { - println!("Environment build error: {}", e); - ProcessError(e.to_string()) - })?; - - println!("Generating proof..."); - - let receipt = default_prover() - .prove_with_ctx( - env, - &VerifierContext::default(), - GUEST_ELF, - &ProverOpts::groth16(), - ) - .map_err(|e| ProcessError(e.to_string()))? - .receipt; - - println!("Verifying receipt..."); - receipt.verify(GUEST_ID) - .map_err(|e| { - println!("Receipt verification error: {}", e); - ProcessError(e.to_string()) - })?; - - println!("Decoding journal..."); - let mut output: Response = receipt.journal.decode() - .map_err(|e| { - println!("Journal decode error: {}", e); - ProcessError(e.to_string()) - })?; - - let journal_hex = hex::encode(&receipt.journal.bytes); - output.receipt = Some(journal_hex); - - Ok::(output) - }) - .await; - - match result { - Ok(Ok(output)) => HttpResponse::Ok().json(output), - Ok(Err(e)) => { - println!("Processing error: {}", e); - HttpResponse::InternalServerError().json(format!("Processing error: {}", e)) - }, - Err(e) => { - println!("Blocking error: {}", e); - HttpResponse::InternalServerError().json(format!("Server error: {}", e)) - } - } -} - -#[actix_web::main] -async fn main() -> std::io::Result<()> { - dotenv::dotenv().ok(); - println!("Starting server on port 3001..."); - - HttpServer::new(|| { - App::new() - .route("/process", web::post().to(process)) - }) - .bind("127.0.0.1:3001")? - .run() - .await -} \ No newline at end of file diff --git a/risc0-merkle-service/methods/Cargo.toml b/risc0-merkle-service/methods/Cargo.toml deleted file mode 100644 index d33c733..0000000 --- a/risc0-merkle-service/methods/Cargo.toml +++ /dev/null @@ -1,13 +0,0 @@ -[package] -name = "methods" -version = "0.1.0" -edition = "2021" - -[build-dependencies] -risc0-build = { version = "1.2.0" } - -[dependencies] -bytemuck_derive = "=1.8.1" - -[package.metadata.risc0] -methods = ["guest"] diff --git a/risc0-merkle-service/methods/build.rs b/risc0-merkle-service/methods/build.rs deleted file mode 100644 index 08a8a4e..0000000 --- a/risc0-merkle-service/methods/build.rs +++ /dev/null @@ -1,3 +0,0 @@ -fn main() { - risc0_build::embed_methods(); -} diff --git a/risc0-merkle-service/methods/guest/Cargo.toml b/risc0-merkle-service/methods/guest/Cargo.toml deleted file mode 100644 index 505400c..0000000 --- a/risc0-merkle-service/methods/guest/Cargo.toml +++ /dev/null @@ -1,14 +0,0 @@ -[package] -name = "guest" -version = "0.1.0" -edition = "2021" - -[workspace] - -[dependencies] -risc0-zkvm = { version = "1.2.0", default-features = false, features = ['std'] } -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -sha2 = "0.10" -hex = "0.4" -bytemuck_derive = "=1.8.1" diff --git a/risc0-merkle-service/methods/guest/src/main.rs b/risc0-merkle-service/methods/guest/src/main.rs deleted file mode 100644 index 90d8edb..0000000 --- a/risc0-merkle-service/methods/guest/src/main.rs +++ /dev/null @@ -1,171 +0,0 @@ -use risc0_zkvm::guest::env; -use sha2::{Sha256, Digest}; -use serde::{Serialize, Deserialize}; - -#[derive(Serialize, Deserialize)] -struct MerkleProof { - leaf_value: String, - proof_path: Vec<(String, bool)>, // (hash, is_right) -} - -struct MerkleTree { - leaves: Vec, - nodes: Vec>, - data_values: Vec, // Store original data values -} - -impl MerkleTree { - fn new() -> Self { - MerkleTree { - leaves: Vec::new(), - nodes: Vec::new(), - data_values: Vec::new(), - } - } - - fn hash(data: &str) -> String { - let mut hasher = Sha256::new(); - hasher.update(data.as_bytes()); - format!("{:x}", hasher.finalize()) - } - - fn insert(&mut self, data: String) { - let leaf_hash = Self::hash(&data); - self.leaves.push(leaf_hash.clone()); - self.data_values.push(data); - - // Rebuild the tree after inserting new leaf - self.nodes.clear(); - let mut current_level = self.leaves.clone(); - - while current_level.len() > 1 { - let mut next_level = Vec::new(); - - for chunk in current_level.chunks(2) { - if chunk.len() == 2 { - let combined = format!("{}{}", chunk[0], chunk[1]); - let parent_hash = Self::hash(&combined); - next_level.push(parent_hash); - } else { - next_level.push(chunk[0].clone()); - } - } - - // Only push internal nodes to self.nodes, not the leaves - if next_level.len() > 0 { // Only add non-leaf levels - self.nodes.push(next_level.clone()); - } - current_level = next_level; - } - } - - fn generate_proof(&self, leaf_value: &str) -> Option { - let leaf_hash = Self::hash(leaf_value); - let mut leaf_index = self.leaves.iter().position(|x| x == &leaf_hash)?; - let mut proof_path = Vec::new(); - - // Start with leaf level - let mut current_level = &self.leaves; - - // Traverse up through all internal node levels - for level in &self.nodes { - let sibling_idx = if leaf_index % 2 == 0 { - leaf_index + 1 - } else { - leaf_index - 1 - }; - - // Only add to proof path if sibling exists - if sibling_idx < current_level.len() { - proof_path.push((current_level[sibling_idx].clone(), leaf_index % 2 == 0)); - } - - // Update index for next level up - leaf_index /= 2; - current_level = level; - } - - Some(MerkleProof { - leaf_value: leaf_value.to_string(), - proof_path, - }) - } - - fn verify_proof(&self, proof: &MerkleProof) -> bool { - let mut current_hash = Self::hash(&proof.leaf_value); - - for (sibling_hash, is_right) in &proof.proof_path { - let combined = if *is_right { - format!("{}{}", current_hash, sibling_hash) - } else { - format!("{}{}", sibling_hash, current_hash) - }; - current_hash = Self::hash(&combined); - } - - Some(current_hash) == self.get_root() - } - - fn get_root(&self) -> Option { - self.nodes.last() - .and_then(|level| level.first()) - .cloned() - .or_else(|| self.leaves.first().cloned()) - } -} - -#[derive(Deserialize)] -struct Input { - operation: String, - data: Vec, - proof_request: Option, - proof: Option, -} - -#[derive(Serialize)] -struct Output { - root: Option, - proof: Option, - verified: Option, - receipt: Option, -} - -fn main() { - let input: Input = env::read(); - let mut tree = MerkleTree::new(); - - let output = match input.operation.as_str() { - "prove" => { - for item in input.data { - tree.insert(item); - } - let proof = input.proof_request.and_then(|value| tree.generate_proof(&value)); - Output { - root: tree.get_root(), - proof, - verified: None, - receipt: None, - } - }, - "verify" => { - for item in input.data { - tree.insert(item); - } - let verified = input.proof.map(|proof| tree.verify_proof(&proof)); - Output { - root: tree.get_root(), - proof: None, - verified, - receipt: None, - } - }, - _ => Output { - root: None, - proof: None, - verified: None, - receipt: None - }, - }; - - env::commit(&output); -} \ No newline at end of file diff --git a/risc0-merkle-service/methods/src/lib.rs b/risc0-merkle-service/methods/src/lib.rs deleted file mode 100644 index 1bdb308..0000000 --- a/risc0-merkle-service/methods/src/lib.rs +++ /dev/null @@ -1 +0,0 @@ -include!(concat!(env!("OUT_DIR"), "/methods.rs")); diff --git a/risc0-merkle-service/run_merkle_tree.sh b/risc0-merkle-service/run_merkle_tree.sh deleted file mode 100755 index 26e4445..0000000 --- a/risc0-merkle-service/run_merkle_tree.sh +++ /dev/null @@ -1,80 +0,0 @@ -#!/bin/bash - -if [ "$#" -ne 1 ]; then - echo "Usage: $0 " - exit 1 -fi - -REPO_PATH="$1" -SERVER_ENDPOINT="http://localhost:8080" - -if [ ! -d "$REPO_PATH" ]; then - echo "Error: Directory $REPO_PATH does not exist." - exit 1 -fi - -cd "$REPO_PATH" || exit 1 - -check_server_running() { - while ! curl -s $SERVER_ENDPOINT/ > /dev/null; do - echo "Waiting for the Rust server to start" - sleep 10 - done - echo "Rust server is running." -} - -echo "Starting Rust server" -cargo run &> server.log & -SERVER_PID=$! - -check_server_running - -echo "Enter data for the Merkle Tree (comma-separated, e.g., data1,data2,data3):" -read -r MERKLE_DATA -IFS=',' read -r -a DATA_ARRAY <<< "$MERKLE_DATA" - -DATA_JSON=$(printf '"%s",' "${DATA_ARRAY[@]}" | sed 's/,$//') - -echo "Inserting data into the Merkle Tree" -INSERT_RESPONSE=$(curl -s -X POST $SERVER_ENDPOINT/process \ - -H "Content-Type: application/json" \ - -d "{ - \"operation\": \"insert\", - \"data\": [$DATA_JSON], - \"proof_request\": null, - \"proof\": null - }") -MERKLE_ROOT=$(echo "$INSERT_RESPONSE" | jq -r '.root') -echo "Merkle Root: $MERKLE_ROOT" - -for LEAF_DATA in "${DATA_ARRAY[@]}"; do - echo "Generating Merkle proof for leaf data: $LEAF_DATA" - PROOF_RESPONSE=$(curl -s -X POST $SERVER_ENDPOINT/process \ - -H "Content-Type: application/json" \ - -d "{ - \"operation\": \"prove\", - \"data\": [$DATA_JSON], - \"proof_request\": \"$LEAF_DATA\", - \"proof\": null - }") - MERKLE_PROOF=$(echo "$PROOF_RESPONSE" | jq -c '.proof') - echo "Merkle Proof for $LEAF_DATA: $MERKLE_PROOF" - - echo "Verifying Merkle proof for leaf data: $LEAF_DATA" - VERIFY_RESPONSE=$(curl -s -X POST $SERVER_ENDPOINT/process \ - -H "Content-Type: application/json" \ - -d "{ - \"operation\": \"verify\", - \"data\": [$DATA_JSON], - \"proof_request\": null, - \"proof\": $MERKLE_PROOF - }") - VERIFIED=$(echo "$VERIFY_RESPONSE" | jq -r '.verified') - echo "Proof Verified for $LEAF_DATA: $VERIFIED" -done - -echo "Stopping Rust server" -kill "$SERVER_PID" - -echo "Done" -echo "Final Merkle Root: $MERKLE_ROOT" diff --git a/risc0-merkle-service/rust-toolchain.toml b/risc0-merkle-service/rust-toolchain.toml deleted file mode 100644 index 36614c3..0000000 --- a/risc0-merkle-service/rust-toolchain.toml +++ /dev/null @@ -1,4 +0,0 @@ -[toolchain] -channel = "stable" -components = ["rustfmt", "rust-src"] -profile = "minimal" From d32f05a445048968108182ea8622cb300cb4f677 Mon Sep 17 00:00:00 2001 From: Kunjal Tandel Date: Mon, 10 Nov 2025 23:10:03 +0530 Subject: [PATCH 2/2] feat: added risc0-merkle-service submodule --- .gitmodules | 3 +++ risc0-merkle-service | 1 + 2 files changed, 4 insertions(+) create mode 100644 .gitmodules create mode 160000 risc0-merkle-service diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..d34bef3 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "risc0-merkle-service"] + path = risc0-merkle-service + url = git@github.com:Layer-Edge/risc0-merkle-service.git diff --git a/risc0-merkle-service b/risc0-merkle-service new file mode 160000 index 0000000..4c173ff --- /dev/null +++ b/risc0-merkle-service @@ -0,0 +1 @@ +Subproject commit 4c173ffc7ee62b8d164828482548b606eba73ba7