From c8878921d3b3d8bba5e8703109f9aef5686c95f0 Mon Sep 17 00:00:00 2001 From: Ryan <80392855+RayXpub@users.noreply.github.com> Date: Wed, 22 Apr 2026 18:56:25 +0200 Subject: [PATCH 1/2] chore: reorg codegen logic and add test gobindings --- .../internal/families/evm/abi.go | 422 +++ .../families/evm/{evm_test.go => abi_test.go} | 145 +- .../internal/families/evm/codegen.go | 257 ++ .../internal/families/evm/codegen_test.go | 116 + .../internal/families/evm/config.go | 27 + .../internal/families/evm/contract.go | 173 ++ .../internal/families/evm/evm.go | 868 +----- .../internal/families/evm/evm_golden_test.go | 13 +- .../v1_0_0/link_token/link_token.go | 2038 ++++++++++++++ .../many_chain_multisig.go | 1238 +++++++++ .../v1_0_0/rbac_timelock/rbac_timelock.go | 2336 +++++++++++++++++ 11 files changed, 6637 insertions(+), 996 deletions(-) create mode 100644 tools/operations-gen/internal/families/evm/abi.go rename tools/operations-gen/internal/families/evm/{evm_test.go => abi_test.go} (50%) create mode 100644 tools/operations-gen/internal/families/evm/codegen.go create mode 100644 tools/operations-gen/internal/families/evm/codegen_test.go create mode 100644 tools/operations-gen/internal/families/evm/config.go create mode 100644 tools/operations-gen/internal/families/evm/contract.go create mode 100644 tools/operations-gen/testdata/evm/gobindings/v1_0_0/link_token/link_token.go create mode 100644 tools/operations-gen/testdata/evm/gobindings/v1_0_0/many_chain_multisig/many_chain_multisig.go create mode 100644 tools/operations-gen/testdata/evm/gobindings/v1_0_0/rbac_timelock/rbac_timelock.go diff --git a/tools/operations-gen/internal/families/evm/abi.go b/tools/operations-gen/internal/families/evm/abi.go new file mode 100644 index 000000000..17ec9c20d --- /dev/null +++ b/tools/operations-gen/internal/families/evm/abi.go @@ -0,0 +1,422 @@ +package evm + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + "strconv" + "strings" + + "github.com/smartcontractkit/chainlink-deployments-framework/tools/operations-gen/internal/core" +) + +// EvmTypeMap maps Solidity types to their Go equivalents. +var EvmTypeMap = map[string]string{ + "address": "common.Address", + "string": "string", + "bool": "bool", + "bytes": "[]byte", + "bytes32": "[32]byte", + "bytes16": "[16]byte", + "bytes4": "[4]byte", + "uint8": "uint8", + "uint16": "uint16", + "uint32": "uint32", + "uint40": "uint64", + "uint48": "uint64", + "uint56": "uint64", + "uint64": "uint64", + "uint96": "*big.Int", + "uint128": "*big.Int", + "uint160": "*big.Int", + "uint192": "*big.Int", + "uint224": "*big.Int", + "uint256": "*big.Int", + "int8": "int8", + "int16": "int16", + "int32": "int32", + "int64": "int64", + "int96": "*big.Int", + "int128": "*big.Int", + "int160": "*big.Int", + "int192": "*big.Int", + "int224": "*big.Int", + "int256": "*big.Int", +} + +// ABIEntry represents a single entry in a Solidity contract ABI JSON. +type ABIEntry struct { + Type string `json:"type"` + Name string `json:"name"` + Inputs []ABIParam `json:"inputs"` + Outputs []ABIParam `json:"outputs"` + StateMutability string `json:"stateMutability"` +} + +// ABIParam represents a parameter within an ABI entry. +type ABIParam struct { + Name string `json:"name"` + Type string `json:"type"` + InternalType string `json:"internalType"` + Components []ABIParam `json:"components"` +} + +// ReadABIAndByteCode reads the ABI JSON and (optionally) bytecode for a contract +// from the configured input roots: +// +// {input.ABIBasePath}/{versionPath}/{name}.json +// {input.BytecodeBasePath}/{versionPath}/{name}.bin +func ReadABIAndByteCode( + cfg EvmContractConfig, + packageName, + versionPath string, + input EvmInputConfig) (abiString string, bytecode string, err error) { + var abiFileName string + if cfg.ABIFile != "" { + if !strings.HasSuffix(cfg.ABIFile, ".json") { + return "", "", fmt.Errorf("abi_file %q must end with .json", cfg.ABIFile) + } + abiFileName = cfg.ABIFile + } else { + abiFileName = packageName + ".json" + } + + abiPath := filepath.Join(input.ABIBasePath, versionPath, abiFileName) + abiBytes, err := os.ReadFile(abiPath) + if err != nil { + return "", "", fmt.Errorf("failed to read ABI from %s: %w", abiPath, err) + } + + if cfg.OmitDeploy { + return string(abiBytes), "", nil + } + + bytecodeName := strings.TrimSuffix(abiFileName, ".json") + ".bin" + bytecodePath := filepath.Join(input.BytecodeBasePath, versionPath, bytecodeName) + bytecodeBytes, err := os.ReadFile(bytecodePath) + if err != nil { + return "", "", fmt.Errorf("failed to read bytecode from %s: %w", bytecodePath, err) + } + + return string(abiBytes), strings.TrimSpace(string(bytecodeBytes)), nil +} + +// FindFunctionInABI finds all overloads of a function by name and returns FunctionInfo +// for each, following Geth's overload naming convention. +func FindFunctionInABI(entries []ABIEntry, funcName string, packageName string, typeMap map[string]string) []*FunctionInfo { + var candidates []ABIEntry + for _, entry := range entries { + if entry.Type == abiTypeFunction && strings.EqualFold(entry.Name, funcName) { + candidates = append(candidates, entry) + } + } + + if len(candidates) == 0 { + return nil + } + + var funcInfos []*FunctionInfo + for i, candidate := range candidates { + fi := ParseABIFunction(candidate, packageName, typeMap) + + // Follow Geth's overload naming convention: + // First: no suffix, second: "0", third: "1", etc. + if len(candidates) > 1 && i > 0 { + suffix := strconv.Itoa(i - 1) + fi.Name = fi.Name + suffix + fi.CallMethod = fi.CallMethod + suffix + } + + funcInfos = append(funcInfos, fi) + } + + return funcInfos +} + +// ParseABIFunction converts a Solidity ABI function entry into a FunctionInfo. +// IsWrite is determined by stateMutability: anything other than "view" or "pure" is a write. +func ParseABIFunction(entry ABIEntry, packageName string, typeMap map[string]string) *FunctionInfo { + fi := &FunctionInfo{ + Name: core.Capitalize(entry.Name), + CallMethod: entry.Name, + IsWrite: entry.StateMutability != stateMutabilityView && entry.StateMutability != stateMutabilityPure, + } + + for i, input := range entry.Inputs { + p := parseABIParam(input, packageName, typeMap) + if p.Name == "" { + p.Name = fmt.Sprintf("arg%d", i) + } + fi.Parameters = append(fi.Parameters, p) + } + + for i, output := range entry.Outputs { + p := parseABIParam(output, packageName, typeMap) + if p.Name == "" { + p.Name = fmt.Sprintf("ret%d", i) + } + fi.ReturnParams = append(fi.ReturnParams, p) + } + + return fi +} + +//nolint:unparam +func parseABIParam(param ABIParam, packageName string, typeMap map[string]string) ParameterInfo { + goType := SolidityToGoType(param.Type, typeMap) + + pi := ParameterInfo{ + Name: param.Name, + SolidityType: param.Type, + GoType: goType, + } + + if strings.HasPrefix(param.Type, "tuple") { + structName := ExtractStructName(param.InternalType) + if structName != "" { + pi.IsStruct = true + pi.StructName = structName + + if strings.HasSuffix(param.Type, "[]") { + pi.GoType = "[]" + structName + } else { + pi.GoType = structName + } + + for _, comp := range param.Components { + pi.Components = append(pi.Components, parseABIParam(comp, packageName, typeMap)) + } + } + } + + return pi +} + +// SolidityToGoType maps a Solidity type string to its Go equivalent using typeMap. +func SolidityToGoType(solidityType string, typeMap map[string]string) string { + // Array: uint8[] → []uint8, uint8[32] → [32]uint8 + if i := strings.LastIndexByte(solidityType, '['); i != -1 { + // Guard malformed type strings like "[" or "uint8[" to avoid slicing panics. + if !strings.HasSuffix(solidityType, "]") || i+1 > len(solidityType)-1 { + return anyType + } + sizeStr := solidityType[i+1 : len(solidityType)-1] + _, numErr := strconv.Atoi(sizeStr) + if sizeStr == "" || numErr == nil { + inner := SolidityToGoType(solidityType[:i], typeMap) + if inner != anyType { + return "[" + sizeStr + "]" + inner + } + + return anyType + } + } + if goType, ok := typeMap[solidityType]; ok { + return goType + } + + return anyType +} + +// ExtractStructName parses the Go struct name from a Solidity ABI internalType field. +// e.g. "struct IOnRamp.DestChainConfig" → "DestChainConfig" +// e.g. "struct MyStruct" → "MyStruct" (no module prefix) +// Returns "" for anonymous tuples ("tuple", "tuple[]") so callers fall back to any. +func ExtractStructName(internalType string) string { + if internalType == "" { + return "" + } + + // Bare "tuple" / "tuple[]" have no named struct — callers should fall back to any. + if strings.HasPrefix(internalType, "tuple") { + return "" + } + + normalized := strings.TrimPrefix(internalType, "struct ") + normalized = strings.TrimSuffix(normalized, "[]") + parts := strings.Split(normalized, ".") + + return parts[len(parts)-1] +} + +// parseABIEntries unmarshals a raw ABI JSON string into a slice of ABIEntry. +func parseABIEntries(abiString string) ([]ABIEntry, error) { + var entries []ABIEntry + if err := json.Unmarshal([]byte(abiString), &entries); err != nil { + return nil, fmt.Errorf("failed to parse ABI: %w", err) + } + + return entries, nil +} + +// trimUnderscores strips all leading underscores from s. +func trimUnderscores(s string) string { + return strings.TrimLeft(s, "_") +} + +// SanitizeFieldName strips leading underscores and capitalizes the result, +// producing a valid exported Go identifier for struct fields. +// Returns "" when the result would start with a digit (e.g. "_1" → ""); callers fall back to "Field%d". +// e.g. "_to" → "To", "_value" → "Value", "balance" → "Balance" +func SanitizeFieldName(name string) string { + trimmed := trimUnderscores(name) + if len(trimmed) == 0 || (trimmed[0] >= '0' && trimmed[0] <= '9') { + return "" + } + + return core.Capitalize(trimmed) +} + +// SanitizeParamName strips leading underscores and lowercases the first rune, +// producing a valid unexported Go identifier for method parameters. +// Returns "" when the result would start with a digit (e.g. "_1" → ""); callers fall back to "arg%d". +// e.g. "_to" → "to", "_value" → "value" +func SanitizeParamName(name string) string { + name = trimUnderscores(name) + if len(name) == 0 || (name[0] >= '0' && name[0] <= '9') { + return "" + } + + return strings.ToLower(name[:1]) + name[1:] +} + +// fieldNameOrIndex returns the sanitized exported field name for a struct field, +// or "Field{i}" when the sanitized result would be empty (e.g. numeric-only names). +func fieldNameOrIndex(name string, i int) string { + if n := SanitizeFieldName(name); n != "" { + return n + } + + return fmt.Sprintf("Field%d", i) +} + +// validatePathSegment rejects values that could traverse outside the output base path. +// Absolute paths and any cleaned path containing ".." or a path separator are rejected. +func validatePathSegment(field, value string) error { + if filepath.IsAbs(value) { + return fmt.Errorf("%s must not be an absolute path: %q", field, value) + } + cleaned := filepath.Clean(value) + if strings.Contains(cleaned, "..") || strings.ContainsRune(cleaned, filepath.Separator) { + return fmt.Errorf("%s must not contain path separators or '..': %q", field, value) + } + + return nil +} + +func resolveReturnType(fi *FunctionInfo) string { + if len(fi.ReturnParams) == 1 { + return fi.ReturnParams[0].GoType + } else if len(fi.ReturnParams) > 1 { + return multiReturnStructName(fi.Name) + } + + return emptyReturnType +} + +// prepareContractMethod builds the contractMethodData for a single contract function, +// generating go-ethereum–specific method signatures and bodies. +func prepareContractMethod(fi *FunctionInfo, isWrite bool) contractMethodData { + optsType := "*bind.CallOpts" + if isWrite { + optsType = "*bind.TransactOpts" + } + + params := "opts " + optsType + var methodArgs []string + + if len(fi.Parameters) == 1 { + params += ", args " + fi.Parameters[0].GoType + methodArgs = []string{"args"} + } else if len(fi.Parameters) > 1 { + var sb strings.Builder + for _, p := range fi.Parameters { + paramName := SanitizeParamName(p.Name) + if paramName == "" { + paramName = fmt.Sprintf("arg%d", len(methodArgs)) + } + fmt.Fprintf(&sb, ", %s %s", paramName, p.GoType) + methodArgs = append(methodArgs, paramName) + } + params += sb.String() + } + + returns := "(*types.Transaction, error)" + if !isWrite { + returns = fmt.Sprintf("(%s, error)", resolveReturnType(fi)) + } + + var methodBody string + if isWrite { + methodBody = buildWriteMethodBody(fi.CallMethod, methodArgs) + } else { + methodBody = buildReadMethodBody(fi, methodArgs, resolveReturnType(fi)) + } + + return contractMethodData{ + Name: fi.Name, + MethodName: fi.CallMethod, + Params: params, + Returns: returns, + MethodBody: methodBody, + } +} + +// buildWriteMethodBody generates the body of a write (transact) method. +func buildWriteMethodBody(callMethod string, methodArgs []string) string { + if len(methodArgs) > 0 { + return fmt.Sprintf("return c.contract.Transact(opts, \"%s\", %s)", + callMethod, strings.Join(methodArgs, ", ")) + } + + return fmt.Sprintf("return c.contract.Transact(opts, \"%s\")", callMethod) +} + +// buildReadMethodBody generates the body of a read (call) method. +func buildReadMethodBody(fi *FunctionInfo, methodArgs []string, returnType string) string { + callArgsStr := "" + if len(methodArgs) > 0 { + callArgsStr = ", " + strings.Join(methodArgs, ", ") + } + if len(fi.ReturnParams) == 0 { + return fmt.Sprintf( + `err := c.contract.Call(opts, nil, "%s"%s) + return struct{}{}, err`, + fi.CallMethod, callArgsStr, + ) + } + if len(fi.ReturnParams) > 1 { + return buildMultiReturnMethodBody(fi, callArgsStr, returnType) + } + + return fmt.Sprintf( + `var out []any + err := c.contract.Call(opts, &out, "%s"%s) + if err != nil { + var zero %s + return zero, err + } + return *abi.ConvertType(out[0], new(%s)).(*%s), nil`, + fi.CallMethod, callArgsStr, returnType, returnType, returnType, + ) +} + +// buildMultiReturnMethodBody generates the body for a read method with multiple return values, +// packing them into a result struct. +func buildMultiReturnMethodBody(fi *FunctionInfo, callArgsStr, returnType string) string { + var b strings.Builder + fmt.Fprintf(&b, "var out []any\n") + fmt.Fprintf(&b, "\terr := c.contract.Call(opts, &out, \"%s\"%s)\n", fi.CallMethod, callArgsStr) + fmt.Fprintf(&b, "\toutstruct := new(%s)\n", returnType) + fmt.Fprintf(&b, "\tif err != nil {\n") + fmt.Fprintf(&b, "\t\treturn *outstruct, err\n") + fmt.Fprintf(&b, "\t}\n\n") + for i, p := range fi.ReturnParams { + fmt.Fprintf(&b, "\toutstruct.%s = *abi.ConvertType(out[%d], new(%s)).(*%s)\n", + fieldNameOrIndex(p.Name, i), i, p.GoType, p.GoType) + } + fmt.Fprintf(&b, "\n\treturn *outstruct, nil") + + return b.String() +} diff --git a/tools/operations-gen/internal/families/evm/evm_test.go b/tools/operations-gen/internal/families/evm/abi_test.go similarity index 50% rename from tools/operations-gen/internal/families/evm/evm_test.go rename to tools/operations-gen/internal/families/evm/abi_test.go index f5d24dd08..f916ed384 100644 --- a/tools/operations-gen/internal/families/evm/evm_test.go +++ b/tools/operations-gen/internal/families/evm/abi_test.go @@ -1,29 +1,10 @@ -package evm +package evm_test import ( "testing" -) -// TestToSnakeCase covers the algorithmic EVM name-normalisation helper -// across representative contract names and mixed casing patterns. -func TestToSnakeCase(t *testing.T) { - t.Parallel() - cases := []struct{ input, want string }{ - {"OnRamp", "on_ramp"}, - {"OffRamp", "off_ramp"}, - {"LinkToken", "link_token"}, - {"FeeQuoter", "fee_quoter"}, - {"EVM2EVMOnRamp", "evm2evm_on_ramp"}, - } - for _, tc := range cases { - t.Run(tc.input, func(t *testing.T) { - t.Parallel() - if got := toSnakeCase(tc.input); got != tc.want { - t.Errorf("toSnakeCase(%q) = %q, want %q", tc.input, got, tc.want) - } - }) - } -} + "github.com/smartcontractkit/chainlink-deployments-framework/tools/operations-gen/internal/families/evm" +) func TestSolidityToGoType(t *testing.T) { t.Parallel() @@ -60,7 +41,7 @@ func TestSolidityToGoType(t *testing.T) { for _, tc := range cases { t.Run(tc.solidity, func(t *testing.T) { t.Parallel() - if got := solidityToGoType(tc.solidity, evmTypeMap); got != tc.want { + if got := evm.SolidityToGoType(tc.solidity, evm.EvmTypeMap); got != tc.want { t.Errorf("solidityToGoType(%q) = %q, want %q", tc.solidity, got, tc.want) } }) @@ -90,8 +71,8 @@ func TestExtractStructName(t *testing.T) { for _, tc := range cases { t.Run(tc.internalType, func(t *testing.T) { t.Parallel() - if got := extractStructName(tc.internalType); got != tc.want { - t.Errorf("extractStructName(%q) = %q, want %q", tc.internalType, got, tc.want) + if got := evm.ExtractStructName(tc.internalType); got != tc.want { + t.Errorf("ExtractStructName(%q) = %q, want %q", tc.internalType, got, tc.want) } }) } @@ -120,8 +101,8 @@ func TestSanitizeFieldName(t *testing.T) { for _, tc := range cases { t.Run(tc.input, func(t *testing.T) { t.Parallel() - if got := sanitizeFieldName(tc.input); got != tc.want { - t.Errorf("sanitizeFieldName(%q) = %q, want %q", tc.input, got, tc.want) + if got := evm.SanitizeFieldName(tc.input); got != tc.want { + t.Errorf("SanitizeFieldName(%q) = %q, want %q", tc.input, got, tc.want) } }) } @@ -145,8 +126,8 @@ func TestSanitizeParamName(t *testing.T) { for _, tc := range cases { t.Run(tc.input, func(t *testing.T) { t.Parallel() - if got := sanitizeParamName(tc.input); got != tc.want { - t.Errorf("sanitizeParamName(%q) = %q, want %q", tc.input, got, tc.want) + if got := evm.SanitizeParamName(tc.input); got != tc.want { + t.Errorf("SanitizeParamName(%q) = %q, want %q", tc.input, got, tc.want) } }) } @@ -154,13 +135,13 @@ func TestSanitizeParamName(t *testing.T) { func TestFindFunctionInABIOverloads(t *testing.T) { t.Parallel() - entries := []ABIEntry{ - {Type: "function", Name: "transfer", Inputs: []ABIParam{{Name: "to", Type: "address"}, {Name: "amount", Type: "uint256"}}, StateMutability: "nonpayable"}, - {Type: "function", Name: "transfer", Inputs: []ABIParam{{Name: "to", Type: "address"}, {Name: "amount", Type: "uint256"}, {Name: "data", Type: "bytes"}}, StateMutability: "nonpayable"}, - {Type: "function", Name: "transfer", Inputs: []ABIParam{{Name: "to", Type: "address"}, {Name: "amount", Type: "uint256"}, {Name: "data", Type: "bytes"}, {Name: "extra", Type: "bytes32"}}, StateMutability: "nonpayable"}, + entries := []evm.ABIEntry{ + {Type: "function", Name: "transfer", Inputs: []evm.ABIParam{{Name: "to", Type: "address"}, {Name: "amount", Type: "uint256"}}, StateMutability: "nonpayable"}, + {Type: "function", Name: "transfer", Inputs: []evm.ABIParam{{Name: "to", Type: "address"}, {Name: "amount", Type: "uint256"}, {Name: "data", Type: "bytes"}}, StateMutability: "nonpayable"}, + {Type: "function", Name: "transfer", Inputs: []evm.ABIParam{{Name: "to", Type: "address"}, {Name: "amount", Type: "uint256"}, {Name: "data", Type: "bytes"}, {Name: "extra", Type: "bytes32"}}, StateMutability: "nonpayable"}, } - results := findFunctionInABI(entries, "transfer", "mypkg", evmTypeMap) + results := evm.FindFunctionInABI(entries, "transfer", "mypkg", evm.EvmTypeMap) if len(results) != 3 { t.Fatalf("expected 3 overloads, got %d", len(results)) @@ -181,8 +162,8 @@ func TestFindFunctionInABIOverloads(t *testing.T) { func TestReadABIAndBytecodeInvalidABIFileSuffix(t *testing.T) { t.Parallel() - cfg := evmContractConfig{ABIFile: "contract.abi"} - _, _, err := readABIAndBytecode(cfg, "contract", "v1_0_0", evmInputConfig{ + cfg := evm.EvmContractConfig{ABIFile: "contract.abi"} + _, _, err := evm.ReadABIAndByteCode(cfg, "contract", "v1_0_0", evm.EvmInputConfig{ ABIBasePath: t.TempDir(), BytecodeBasePath: t.TempDir(), }) @@ -193,98 +174,10 @@ func TestReadABIAndBytecodeInvalidABIFileSuffix(t *testing.T) { func TestFindFunctionInABINotFound(t *testing.T) { t.Parallel() - entries := []ABIEntry{ + entries := []evm.ABIEntry{ {Type: "function", Name: "transfer"}, } - if got := findFunctionInABI(entries, "mint", "pkg", evmTypeMap); got != nil { + if got := evm.FindFunctionInABI(entries, "mint", "pkg", evm.EvmTypeMap); got != nil { t.Errorf("expected nil for missing function, got %v", got) } } - -func TestCheckNeedsBigInt(t *testing.T) { - t.Parallel() - makeFuncInfo := func(goType string) *functionInfo { - return &functionInfo{ - Name: "Foo", - Parameters: []parameterInfo{{GoType: goType}}, - } - } - - t.Run("parameter needs big.Int", func(t *testing.T) { - t.Parallel() - info := &contractInfo{ - Functions: map[string]*functionInfo{"Foo": makeFuncInfo("*big.Int")}, - FunctionOrder: []string{"Foo"}, - } - if !checkNeedsBigInt(info) { - t.Error("expected true") - } - }) - - t.Run("return param needs big.Int", func(t *testing.T) { - t.Parallel() - info := &contractInfo{ - Functions: map[string]*functionInfo{ - "Foo": {Name: "Foo", ReturnParams: []parameterInfo{{GoType: "*big.Int"}}}, - }, - FunctionOrder: []string{"Foo"}, - } - if !checkNeedsBigInt(info) { - t.Error("expected true") - } - }) - - t.Run("constructor param needs big.Int", func(t *testing.T) { - t.Parallel() - entry := ABIEntry{ - Type: "constructor", - Inputs: []ABIParam{{Name: "supply", Type: "uint256"}}, - } - fi := parseABIFunction(entry, "pkg", evmTypeMap) - info := &contractInfo{ - Constructor: fi, - Functions: map[string]*functionInfo{}, - FunctionOrder: []string{}, - } - if !checkNeedsBigInt(info) { - t.Error("expected true for constructor uint256 param") - } - }) - - t.Run("no big.Int", func(t *testing.T) { - t.Parallel() - info := &contractInfo{ - Functions: map[string]*functionInfo{"Foo": makeFuncInfo("common.Address")}, - FunctionOrder: []string{"Foo"}, - } - if checkNeedsBigInt(info) { - t.Error("expected false") - } - }) - - t.Run("nested tuple component needs big.Int", func(t *testing.T) { - t.Parallel() - info := &contractInfo{ - Functions: map[string]*functionInfo{ - "Foo": { - Name: "Foo", - Parameters: []parameterInfo{ - { - Name: "metadata", - GoType: "RootMetadata", - IsStruct: true, - StructName: "RootMetadata", - Components: []parameterInfo{ - {Name: "chainId", GoType: "*big.Int"}, - }, - }, - }, - }, - }, - FunctionOrder: []string{"Foo"}, - } - if !checkNeedsBigInt(info) { - t.Error("expected true for nested tuple component using *big.Int") - } - }) -} diff --git a/tools/operations-gen/internal/families/evm/codegen.go b/tools/operations-gen/internal/families/evm/codegen.go new file mode 100644 index 000000000..e088f8002 --- /dev/null +++ b/tools/operations-gen/internal/families/evm/codegen.go @@ -0,0 +1,257 @@ +package evm + +import ( + "bytes" + "fmt" + "sort" + "strings" + "text/template" + + "github.com/smartcontractkit/chainlink-deployments-framework/tools/operations-gen/internal/core" +) + +// ---- Template data (EVM-specific) ---- + +type templateData struct { + PackageName string + PackageNameHyphen string + ContractType string + Version string + ABI string + Bytecode string + NeedsBigInt bool + HasWriteOps bool + OmitDeploy bool + Constructor *constructorData + StructDefs []structDefData + ArgStructs []argStructData + Operations []operationData + ContractMethods []contractMethodData +} + +type constructorData struct { + Parameters []parameterData +} + +type structDefData struct { + Name string + Fields []parameterData +} + +type argStructData struct { + Name string + Fields []parameterData +} + +type parameterData struct { + GoName string + GoType string + JSONTag string // ABI parameter name; may be a synthesized placeholder (e.g. "ret0") for unnamed outputs +} + +type operationData struct { + Name string + MethodName string + OpName string + ArgsType string + CallArgs string + IsWrite bool + AccessControl string // Only for writes + ReturnType string // Only for reads +} + +type contractMethodData struct { + Name string + MethodName string + Params string + Returns string + MethodBody string +} + +func generateOperationsFile(info *ContractInfo, tmpl *template.Template) error { + data := prepareTemplateData(info) + + var buf bytes.Buffer + if err := tmpl.Execute(&buf, data); err != nil { + return fmt.Errorf("template execution error: %w", err) + } + + return core.WriteGoFile(info.OutputPath, buf.Bytes()) +} + +func prepareTemplateData(info *ContractInfo) templateData { + data := templateData{ + PackageName: info.PackageName, + PackageNameHyphen: toKebabCase(info.PackageName), + ContractType: info.Name, + Version: info.Version, + ABI: info.ABI, + Bytecode: info.Bytecode, + NeedsBigInt: ChecksNeedsBigInt(info), + OmitDeploy: info.OmitDeploy, + } + + if info.Constructor != nil { + data.Constructor = &constructorData{ + Parameters: prepareParameters(info.Constructor.Parameters), + } + } + + for _, name := range info.FunctionOrder { + fi := info.Functions[name] + data.ContractMethods = append(data.ContractMethods, prepareContractMethod(fi, fi.IsWrite)) + + if fi.IsWrite { + data.HasWriteOps = true + data.Operations = append(data.Operations, prepareWriteOp(fi)) + } else { + data.Operations = append(data.Operations, prepareReadOp(fi)) + } + + if len(fi.Parameters) > 1 { + data.ArgStructs = append(data.ArgStructs, argStructData{ + Name: fi.Name + "Args", + Fields: prepareParameters(fi.Parameters), + }) + } + } + + structNames := make([]string, 0, len(info.StructDefs)) + for name := range info.StructDefs { + structNames = append(structNames, name) + } + sort.Strings(structNames) + for _, name := range structNames { + sd := info.StructDefs[name] + data.StructDefs = append(data.StructDefs, structDefData{ + Name: sd.Name, + Fields: prepareParameters(sd.Fields), + }) + } + + return data +} + +// ChecksNeedsBigInt reports whether any parameter in the contract uses *big.Int, +// which requires importing "math/big" in the generated file. +func ChecksNeedsBigInt(info *ContractInfo) bool { + var check func(params []ParameterInfo) bool + check = func(params []ParameterInfo) bool { + for _, p := range params { + if strings.Contains(p.GoType, "*big.Int") { + return true + } + if len(p.Components) > 0 && check(p.Components) { + return true + } + } + + return false + } + + for _, fi := range info.Functions { + if check(fi.Parameters) || check(fi.ReturnParams) { + return true + } + } + + if info.Constructor != nil && check(info.Constructor.Parameters) { + return true + } + + return false +} + +func prepareParameters(params []ParameterInfo) []parameterData { + result := make([]parameterData, 0, len(params)) + for i, param := range params { + result = append(result, parameterData{ + GoName: fieldNameOrIndex(param.Name, i), + GoType: param.GoType, + JSONTag: param.Name, + }) + } + + return result +} + +func prepareWriteOp(fi *FunctionInfo) operationData { + argsType, callArgs := buildCallArgs(fi) + + accessControl := accessControlAllCallers + if fi.HasOnlyOwner { + accessControl = accessControlOnlyOwner + } + + return operationData{ + Name: fi.Name, + MethodName: fi.CallMethod, + OpName: toKebabCase(fi.Name), + ArgsType: argsType, + CallArgs: callArgs, + IsWrite: true, + AccessControl: accessControl, + } +} + +func prepareReadOp(fi *FunctionInfo) operationData { + argsType, callArgs := buildCallArgs(fi) + + return operationData{ + Name: fi.Name, + MethodName: fi.CallMethod, + OpName: toKebabCase(fi.Name), + ArgsType: argsType, + ReturnType: resolveReturnType(fi), + CallArgs: callArgs, + IsWrite: false, + } +} + +// buildCallArgs builds the argsType and callArgs strings for an operation. +func buildCallArgs(fi *FunctionInfo) (argsType string, callArgs string) { + if len(fi.Parameters) == 0 { + return emptyReturnType, "" + } + + if len(fi.Parameters) == 1 { + return fi.Parameters[0].GoType, ", args" + } + + argsType = fi.Name + "Args" + callArgsList := make([]string, 0, len(fi.Parameters)) + for i, p := range fi.Parameters { + callArgsList = append(callArgsList, "args."+fieldNameOrIndex(p.Name, i)) + } + callArgs = ", " + strings.Join(callArgsList, ", ") + + return argsType, callArgs +} + +func multiReturnStructName(funcName string) string { + return funcName + "Result" +} + +// ---- Naming utilities ---- + +func ToSnakeCase(s string) string { + var result []rune + runes := []rune(s) + for i := range runes { + r := runes[i] + if i > 0 && r >= 'A' && r <= 'Z' { + prevLower := runes[i-1] >= 'a' && runes[i-1] <= 'z' + nextLower := i+1 < len(runes) && runes[i+1] >= 'a' && runes[i+1] <= 'z' + if prevLower || nextLower { + result = append(result, '_') + } + } + result = append(result, r) + } + + return strings.ToLower(string(result)) +} + +func toKebabCase(s string) string { + return strings.ReplaceAll(ToSnakeCase(s), "_", "-") +} diff --git a/tools/operations-gen/internal/families/evm/codegen_test.go b/tools/operations-gen/internal/families/evm/codegen_test.go new file mode 100644 index 000000000..a8aacbebd --- /dev/null +++ b/tools/operations-gen/internal/families/evm/codegen_test.go @@ -0,0 +1,116 @@ +package evm_test + +import ( + "testing" + + "github.com/smartcontractkit/chainlink-deployments-framework/tools/operations-gen/internal/families/evm" +) + +// TestToSnakeCase covers the algorithmic EVM name-normalisation helper +// across representative contract names and mixed casing patterns. +func TestToSnakeCase(t *testing.T) { + t.Parallel() + cases := []struct{ input, want string }{ + {"OnRamp", "on_ramp"}, + {"OffRamp", "off_ramp"}, + {"LinkToken", "link_token"}, + {"FeeQuoter", "fee_quoter"}, + {"EVM2EVMOnRamp", "evm2evm_on_ramp"}, + } + for _, tc := range cases { + t.Run(tc.input, func(t *testing.T) { + t.Parallel() + if got := evm.ToSnakeCase(tc.input); got != tc.want { + t.Errorf("ToSnakeCase(%q) = %q, want %q", tc.input, got, tc.want) + } + }) + } +} + +func TestCheckNeedsBigInt(t *testing.T) { + t.Parallel() + makeFuncInfo := func(goType string) *evm.FunctionInfo { + return &evm.FunctionInfo{ + Name: "Foo", + Parameters: []evm.ParameterInfo{{GoType: goType}}, + } + } + + t.Run("parameter needs big.Int", func(t *testing.T) { + t.Parallel() + info := &evm.ContractInfo{ + Functions: map[string]*evm.FunctionInfo{"Foo": makeFuncInfo("*big.Int")}, + FunctionOrder: []string{"Foo"}, + } + if !evm.ChecksNeedsBigInt(info) { + t.Error("expected true") + } + }) + + t.Run("return param needs big.Int", func(t *testing.T) { + t.Parallel() + info := &evm.ContractInfo{ + Functions: map[string]*evm.FunctionInfo{ + "Foo": {Name: "Foo", ReturnParams: []evm.ParameterInfo{{GoType: "*big.Int"}}}, + }, + FunctionOrder: []string{"Foo"}, + } + if !evm.ChecksNeedsBigInt(info) { + t.Error("expected true") + } + }) + + t.Run("constructor param needs big.Int", func(t *testing.T) { + t.Parallel() + entry := evm.ABIEntry{ + Type: "constructor", + Inputs: []evm.ABIParam{{Name: "supply", Type: "uint256"}}, + } + fi := evm.ParseABIFunction(entry, "pkg", evm.EvmTypeMap) + info := &evm.ContractInfo{ + Constructor: fi, + Functions: map[string]*evm.FunctionInfo{}, + FunctionOrder: []string{}, + } + if !evm.ChecksNeedsBigInt(info) { + t.Error("expected true for constructor uint256 param") + } + }) + + t.Run("no big.Int", func(t *testing.T) { + t.Parallel() + info := &evm.ContractInfo{ + Functions: map[string]*evm.FunctionInfo{"Foo": makeFuncInfo("common.Address")}, + FunctionOrder: []string{"Foo"}, + } + if evm.ChecksNeedsBigInt(info) { + t.Error("expected false") + } + }) + + t.Run("nested tuple component needs big.Int", func(t *testing.T) { + t.Parallel() + info := &evm.ContractInfo{ + Functions: map[string]*evm.FunctionInfo{ + "Foo": { + Name: "Foo", + Parameters: []evm.ParameterInfo{ + { + Name: "metadata", + GoType: "RootMetadata", + IsStruct: true, + StructName: "RootMetadata", + Components: []evm.ParameterInfo{ + {Name: "chainId", GoType: "*big.Int"}, + }, + }, + }, + }, + }, + FunctionOrder: []string{"Foo"}, + } + if !evm.ChecksNeedsBigInt(info) { + t.Error("expected true for nested tuple component using *big.Int") + } + }) +} diff --git a/tools/operations-gen/internal/families/evm/config.go b/tools/operations-gen/internal/families/evm/config.go new file mode 100644 index 000000000..47cd88e07 --- /dev/null +++ b/tools/operations-gen/internal/families/evm/config.go @@ -0,0 +1,27 @@ +package evm + +// EvmContractConfig is the EVM-specific contract configuration decoded from YAML. +type EvmContractConfig struct { + Name string `yaml:"contract_name"` + Version string `yaml:"version"` + VersionPath string `yaml:"version_path,omitempty"` // Optional: override folder path derived from version + PackageName string `yaml:"package_name,omitempty"` // Optional: override package name + ABIFile string `yaml:"abi_file,omitempty"` // Optional: override ABI file name + OmitDeploy bool `yaml:"omit_deploy,omitempty"` // Optional: skip Deploy operation + Functions []evmFunctionConfig `yaml:"functions"` +} + +// evmFunctionConfig selects a contract function and assigns its access control. +type evmFunctionConfig struct { + Name string `yaml:"name"` + Access string `yaml:"access,omitempty"` // "owner" or "public" +} + +type EvmInputConfig struct { + ABIBasePath string `yaml:"abi_base_path"` + BytecodeBasePath string `yaml:"bytecode_base_path"` +} + +type EvmOutputConfig struct { + BasePath string `yaml:"base_path"` +} diff --git a/tools/operations-gen/internal/families/evm/contract.go b/tools/operations-gen/internal/families/evm/contract.go new file mode 100644 index 000000000..9506e50de --- /dev/null +++ b/tools/operations-gen/internal/families/evm/contract.go @@ -0,0 +1,173 @@ +package evm + +import ( + "errors" + "fmt" + + "github.com/smartcontractkit/chainlink-deployments-framework/tools/operations-gen/internal/core" +) + +// ---- Intermediate representation ---- + +// ContractInfo holds all parsed information about a contract needed for code generation. +type ContractInfo struct { + Name string + Version string + PackageName string + OutputPath string + ABI string + Bytecode string + OmitDeploy bool + Constructor *FunctionInfo + Functions map[string]*FunctionInfo + FunctionOrder []string + StructDefs map[string]*structDef +} + +type structDef struct { + Name string + Fields []ParameterInfo +} + +type FunctionInfo struct { + Name string + Parameters []ParameterInfo + ReturnParams []ParameterInfo + IsWrite bool + CallMethod string // Method name, with numeric suffix for overloaded functions + HasOnlyOwner bool +} + +type ParameterInfo struct { + Name string + SolidityType string + GoType string + IsStruct bool + StructName string + Components []ParameterInfo +} + +// ---- Extraction ---- + +func extractContractInfo(cfg EvmContractConfig, input EvmInputConfig, output EvmOutputConfig) (*ContractInfo, error) { + if cfg.Name == "" || cfg.Version == "" { + return nil, errors.New("contract_name and version are required") + } + + packageName := cfg.PackageName + if packageName == "" { + packageName = ToSnakeCase(cfg.Name) + } + versionPath := core.VersionToPath(cfg.Version) + if cfg.VersionPath != "" { + versionPath = cfg.VersionPath + } + + if err := validatePathSegment("package_name", packageName); err != nil { + return nil, err + } + if err := validatePathSegment("version_path", versionPath); err != nil { + return nil, err + } + + abiString, bytecode, err := ReadABIAndByteCode(cfg, packageName, versionPath, input) + if err != nil { + return nil, err + } + + abiEntries, err := parseABIEntries(abiString) + if err != nil { + return nil, err + } + + info := &ContractInfo{ + Name: cfg.Name, + Version: cfg.Version, + PackageName: packageName, + OutputPath: core.ContractOutputPath(output.BasePath, versionPath, packageName), + ABI: abiString, + Bytecode: bytecode, + OmitDeploy: cfg.OmitDeploy, + Functions: make(map[string]*FunctionInfo), + StructDefs: make(map[string]*structDef), + } + + extractConstructor(info, abiEntries, EvmTypeMap) + + if err := extractFunctions(info, cfg.Functions, abiEntries, EvmTypeMap); err != nil { + return nil, err + } + + collectAllStructDefs(info) + + return info, nil +} + +func extractConstructor(info *ContractInfo, abiEntries []ABIEntry, typeMap map[string]string) { + for _, entry := range abiEntries { + if entry.Type == abiTypeConstructor { + info.Constructor = ParseABIFunction(entry, info.PackageName, typeMap) + break + } + } +} + +func extractFunctions(info *ContractInfo, funcConfigs []evmFunctionConfig, abiEntries []ABIEntry, typeMap map[string]string) error { + for _, funcCfg := range funcConfigs { + funcInfos := FindFunctionInABI(abiEntries, funcCfg.Name, info.PackageName, typeMap) + if funcInfos == nil { + return fmt.Errorf("function %s not found in ABI", funcCfg.Name) + } + + for _, fi := range funcInfos { + switch funcCfg.Access { + case accessOwner: + fi.HasOnlyOwner = true + case accessPublic, "": + fi.HasOnlyOwner = false + default: + return fmt.Errorf("unknown access control '%s' for function %s (use 'owner' or 'public')", + funcCfg.Access, funcCfg.Name) + } + + info.Functions[fi.Name] = fi + info.FunctionOrder = append(info.FunctionOrder, fi.Name) + } + } + + return nil +} + +func collectAllStructDefs(info *ContractInfo) { + if info.Constructor != nil { + collectStructDefs(info.Constructor.Parameters, info.StructDefs) + } + for _, fi := range info.Functions { + collectStructDefs(fi.Parameters, info.StructDefs) + collectStructDefs(fi.ReturnParams, info.StructDefs) + + if !fi.IsWrite && len(fi.ReturnParams) > 1 { + structName := multiReturnStructName(fi.Name) + if _, exists := info.StructDefs[structName]; !exists { + info.StructDefs[structName] = &structDef{ + Name: structName, + Fields: fi.ReturnParams, + } + } + } + } +} + +func collectStructDefs(params []ParameterInfo, structDefs map[string]*structDef) { + for _, param := range params { + if param.IsStruct && param.StructName != "" { + if _, exists := structDefs[param.StructName]; !exists { + structDefs[param.StructName] = &structDef{ + Name: param.StructName, + Fields: param.Components, + } + } + collectStructDefs(param.Components, structDefs) + } + } +} diff --git a/tools/operations-gen/internal/families/evm/evm.go b/tools/operations-gen/internal/families/evm/evm.go index b8909ee26..8780a0fa7 100644 --- a/tools/operations-gen/internal/families/evm/evm.go +++ b/tools/operations-gen/internal/families/evm/evm.go @@ -1,15 +1,8 @@ package evm import ( - "bytes" - "encoding/json" - "errors" "fmt" - "os" "path/filepath" - "sort" - "strconv" - "strings" "text/template" "github.com/smartcontractkit/chainlink-deployments-framework/tools/operations-gen/internal/core" @@ -31,179 +24,19 @@ const ( accessControlOnlyOwner = "OnlyOwner" ) -// evmTypeMap maps Solidity types to their Go equivalents. -var evmTypeMap = map[string]string{ - "address": "common.Address", - "string": "string", - "bool": "bool", - "bytes": "[]byte", - "bytes32": "[32]byte", - "bytes16": "[16]byte", - "bytes4": "[4]byte", - "uint8": "uint8", - "uint16": "uint16", - "uint32": "uint32", - "uint40": "uint64", - "uint48": "uint64", - "uint56": "uint64", - "uint64": "uint64", - "uint96": "*big.Int", - "uint128": "*big.Int", - "uint160": "*big.Int", - "uint192": "*big.Int", - "uint224": "*big.Int", - "uint256": "*big.Int", - "int8": "int8", - "int16": "int16", - "int32": "int32", - "int64": "int64", - "int96": "*big.Int", - "int128": "*big.Int", - "int160": "*big.Int", - "int192": "*big.Int", - "int224": "*big.Int", - "int256": "*big.Int", -} - -// ---- EVM contract config (YAML schema owned by Handler) ---- - -// evmContractConfig is the EVM-specific contract configuration decoded from YAML. -type evmContractConfig struct { - Name string `yaml:"contract_name"` - Version string `yaml:"version"` - VersionPath string `yaml:"version_path,omitempty"` // Optional: override folder path derived from version - PackageName string `yaml:"package_name,omitempty"` // Optional: override package name - ABIFile string `yaml:"abi_file,omitempty"` // Optional: override ABI file name - OmitDeploy bool `yaml:"omit_deploy,omitempty"` // Optional: skip Deploy operation - Functions []evmFunctionConfig `yaml:"functions"` -} - -// evmFunctionConfig selects a contract function and assigns its access control. -type evmFunctionConfig struct { - Name string `yaml:"name"` - Access string `yaml:"access,omitempty"` // "owner" or "public" -} - -type evmInputConfig struct { - ABIBasePath string `yaml:"abi_base_path"` - BytecodeBasePath string `yaml:"bytecode_base_path"` -} - -type evmOutputConfig struct { - BasePath string `yaml:"base_path"` -} - -// ---- Intermediate representation ---- - -// contractInfo holds all parsed information about a contract needed for code generation. -type contractInfo struct { - Name string - Version string - PackageName string - OutputPath string - ABI string - Bytecode string - OmitDeploy bool - Constructor *functionInfo - Functions map[string]*functionInfo - FunctionOrder []string - StructDefs map[string]*structDef -} - -type structDef struct { - Name string - Fields []parameterInfo -} - -type functionInfo struct { - Name string - Parameters []parameterInfo - ReturnParams []parameterInfo - IsWrite bool - CallMethod string // Method name, with numeric suffix for overloaded functions - HasOnlyOwner bool -} - -type parameterInfo struct { - Name string - SolidityType string - GoType string - IsStruct bool - StructName string - Components []parameterInfo -} - -// ---- Template data (EVM-specific) ---- - -type templateData struct { - PackageName string - PackageNameHyphen string - ContractType string - Version string - ABI string - Bytecode string - NeedsBigInt bool - HasWriteOps bool - OmitDeploy bool - Constructor *constructorData - StructDefs []structDefData - ArgStructs []argStructData - Operations []operationData - ContractMethods []contractMethodData -} - -type constructorData struct { - Parameters []parameterData -} - -type structDefData struct { - Name string - Fields []parameterData -} - -type argStructData struct { - Name string - Fields []parameterData -} - -type parameterData struct { - GoName string - GoType string - JSONTag string // ABI parameter name; may be a synthesized placeholder (e.g. "ret0") for unnamed outputs -} - -type operationData struct { - Name string - MethodName string - OpName string - ArgsType string - CallArgs string - IsWrite bool - AccessControl string // Only for writes - ReturnType string // Only for reads -} - -type contractMethodData struct { - Name string - MethodName string - Params string - Returns string - MethodBody string -} - // ---- Handler ---- // Handler implements ChainFamilyHandler for EVM (Solidity/go-ethereum) chains. type Handler struct{} -// Generate decodes each YAML node as an evmContractConfig, extracts contract info, +// Generate decodes each YAML node as an EvmContractConfig, extracts contract info, // and writes a generated operations file for each contract. func (h Handler) Generate(config core.Config, tmpl *template.Template) error { - var input evmInputConfig + var input EvmInputConfig if err := config.Input.Decode(&input); err != nil { return fmt.Errorf("failed to decode EVM input config: %w", err) } - var output evmOutputConfig + var output EvmOutputConfig if err := config.Output.Decode(&output); err != nil { return fmt.Errorf("failed to decode EVM output config: %w", err) } @@ -217,7 +50,7 @@ func (h Handler) Generate(config core.Config, tmpl *template.Template) error { if node == nil { continue } - var cfg evmContractConfig + var cfg EvmContractConfig if err := node.Decode(&cfg); err != nil { return fmt.Errorf("failed to decode EVM contract config: %w", err) } @@ -236,696 +69,3 @@ func (h Handler) Generate(config core.Config, tmpl *template.Template) error { return nil } - -// ---- Extraction ---- - -func extractContractInfo(cfg evmContractConfig, input evmInputConfig, output evmOutputConfig) (*contractInfo, error) { - if cfg.Name == "" || cfg.Version == "" { - return nil, errors.New("contract_name and version are required") - } - - packageName := cfg.PackageName - if packageName == "" { - packageName = toSnakeCase(cfg.Name) - } - versionPath := core.VersionToPath(cfg.Version) - if cfg.VersionPath != "" { - versionPath = cfg.VersionPath - } - - if err := validatePathSegment("package_name", packageName); err != nil { - return nil, err - } - if err := validatePathSegment("version_path", versionPath); err != nil { - return nil, err - } - - abiString, bytecode, err := readABIAndBytecode(cfg, packageName, versionPath, input) - if err != nil { - return nil, err - } - - abiEntries, err := parseABIEntries(abiString) - if err != nil { - return nil, err - } - - info := &contractInfo{ - Name: cfg.Name, - Version: cfg.Version, - PackageName: packageName, - OutputPath: core.ContractOutputPath(output.BasePath, versionPath, packageName), - ABI: abiString, - Bytecode: bytecode, - OmitDeploy: cfg.OmitDeploy, - Functions: make(map[string]*functionInfo), - StructDefs: make(map[string]*structDef), - } - - extractConstructor(info, abiEntries, evmTypeMap) - - if err := extractFunctions(info, cfg.Functions, abiEntries, evmTypeMap); err != nil { - return nil, err - } - - collectAllStructDefs(info) - - return info, nil -} - -func collectAllStructDefs(info *contractInfo) { - if info.Constructor != nil { - collectStructDefs(info.Constructor.Parameters, info.StructDefs) - } - for _, fi := range info.Functions { - collectStructDefs(fi.Parameters, info.StructDefs) - collectStructDefs(fi.ReturnParams, info.StructDefs) - - if !fi.IsWrite && len(fi.ReturnParams) > 1 { - structName := multiReturnStructName(fi.Name) - if _, exists := info.StructDefs[structName]; !exists { - info.StructDefs[structName] = &structDef{ - Name: structName, - Fields: fi.ReturnParams, - } - } - } - } -} - -func collectStructDefs(params []parameterInfo, structDefs map[string]*structDef) { - for _, param := range params { - if param.IsStruct && param.StructName != "" { - if _, exists := structDefs[param.StructName]; !exists { - structDefs[param.StructName] = &structDef{ - Name: param.StructName, - Fields: param.Components, - } - } - collectStructDefs(param.Components, structDefs) - } - } -} - -// ---- Code generation ---- - -func generateOperationsFile(info *contractInfo, tmpl *template.Template) error { - data := prepareTemplateData(info) - - var buf bytes.Buffer - if err := tmpl.Execute(&buf, data); err != nil { - return fmt.Errorf("template execution error: %w", err) - } - - return core.WriteGoFile(info.OutputPath, buf.Bytes()) -} - -func prepareTemplateData(info *contractInfo) templateData { - data := templateData{ - PackageName: info.PackageName, - PackageNameHyphen: toKebabCase(info.PackageName), - ContractType: info.Name, - Version: info.Version, - ABI: info.ABI, - Bytecode: info.Bytecode, - NeedsBigInt: checkNeedsBigInt(info), - OmitDeploy: info.OmitDeploy, - } - - if info.Constructor != nil { - data.Constructor = &constructorData{ - Parameters: prepareParameters(info.Constructor.Parameters), - } - } - - for _, name := range info.FunctionOrder { - fi := info.Functions[name] - data.ContractMethods = append(data.ContractMethods, prepareContractMethod(fi, fi.IsWrite)) - - if fi.IsWrite { - data.HasWriteOps = true - data.Operations = append(data.Operations, prepareWriteOp(fi)) - } else { - data.Operations = append(data.Operations, prepareReadOp(fi)) - } - - if len(fi.Parameters) > 1 { - data.ArgStructs = append(data.ArgStructs, argStructData{ - Name: fi.Name + "Args", - Fields: prepareParameters(fi.Parameters), - }) - } - } - - structNames := make([]string, 0, len(info.StructDefs)) - for name := range info.StructDefs { - structNames = append(structNames, name) - } - sort.Strings(structNames) - for _, name := range structNames { - sd := info.StructDefs[name] - data.StructDefs = append(data.StructDefs, structDefData{ - Name: sd.Name, - Fields: prepareParameters(sd.Fields), - }) - } - - return data -} - -func prepareParameters(params []parameterInfo) []parameterData { - result := make([]parameterData, 0, len(params)) - for i, param := range params { - result = append(result, parameterData{ - GoName: fieldNameOrIndex(param.Name, i), - GoType: param.GoType, - JSONTag: param.Name, - }) - } - - return result -} - -// buildCallArgs builds the argsType and callArgs strings for an operation. -func buildCallArgs(fi *functionInfo) (argsType string, callArgs string) { - if len(fi.Parameters) == 0 { - return emptyReturnType, "" - } - - if len(fi.Parameters) == 1 { - return fi.Parameters[0].GoType, ", args" - } - - argsType = fi.Name + "Args" - callArgsList := make([]string, 0, len(fi.Parameters)) - for i, p := range fi.Parameters { - callArgsList = append(callArgsList, "args."+fieldNameOrIndex(p.Name, i)) - } - callArgs = ", " + strings.Join(callArgsList, ", ") - - return argsType, callArgs -} - -func resolveReturnType(fi *functionInfo) string { - if len(fi.ReturnParams) == 1 { - return fi.ReturnParams[0].GoType - } else if len(fi.ReturnParams) > 1 { - return multiReturnStructName(fi.Name) - } - - return emptyReturnType -} - -func prepareWriteOp(fi *functionInfo) operationData { - argsType, callArgs := buildCallArgs(fi) - - accessControl := accessControlAllCallers - if fi.HasOnlyOwner { - accessControl = accessControlOnlyOwner - } - - return operationData{ - Name: fi.Name, - MethodName: fi.CallMethod, - OpName: toKebabCase(fi.Name), - ArgsType: argsType, - CallArgs: callArgs, - IsWrite: true, - AccessControl: accessControl, - } -} - -func prepareReadOp(fi *functionInfo) operationData { - argsType, callArgs := buildCallArgs(fi) - - return operationData{ - Name: fi.Name, - MethodName: fi.CallMethod, - OpName: toKebabCase(fi.Name), - ArgsType: argsType, - ReturnType: resolveReturnType(fi), - CallArgs: callArgs, - IsWrite: false, - } -} - -func multiReturnStructName(funcName string) string { - return funcName + "Result" -} - -// prepareContractMethod builds the contractMethodData for a single contract function, -// generating go-ethereum–specific method signatures and bodies. -func prepareContractMethod(fi *functionInfo, isWrite bool) contractMethodData { - optsType := "*bind.CallOpts" - if isWrite { - optsType = "*bind.TransactOpts" - } - - params := "opts " + optsType - var methodArgs []string - - if len(fi.Parameters) == 1 { - params += ", args " + fi.Parameters[0].GoType - methodArgs = []string{"args"} - } else if len(fi.Parameters) > 1 { - var sb strings.Builder - for _, p := range fi.Parameters { - paramName := sanitizeParamName(p.Name) - if paramName == "" { - paramName = fmt.Sprintf("arg%d", len(methodArgs)) - } - fmt.Fprintf(&sb, ", %s %s", paramName, p.GoType) - methodArgs = append(methodArgs, paramName) - } - params += sb.String() - } - - returns := "(*types.Transaction, error)" - if !isWrite { - returns = fmt.Sprintf("(%s, error)", resolveReturnType(fi)) - } - - var methodBody string - if isWrite { - methodBody = buildWriteMethodBody(fi.CallMethod, methodArgs) - } else { - methodBody = buildReadMethodBody(fi, methodArgs, resolveReturnType(fi)) - } - - return contractMethodData{ - Name: fi.Name, - MethodName: fi.CallMethod, - Params: params, - Returns: returns, - MethodBody: methodBody, - } -} - -// buildWriteMethodBody generates the body of a write (transact) method. -func buildWriteMethodBody(callMethod string, methodArgs []string) string { - if len(methodArgs) > 0 { - return fmt.Sprintf("return c.contract.Transact(opts, \"%s\", %s)", - callMethod, strings.Join(methodArgs, ", ")) - } - - return fmt.Sprintf("return c.contract.Transact(opts, \"%s\")", callMethod) -} - -// buildReadMethodBody generates the body of a read (call) method. -func buildReadMethodBody(fi *functionInfo, methodArgs []string, returnType string) string { - callArgsStr := "" - if len(methodArgs) > 0 { - callArgsStr = ", " + strings.Join(methodArgs, ", ") - } - if len(fi.ReturnParams) == 0 { - return fmt.Sprintf( - `err := c.contract.Call(opts, nil, "%s"%s) - return struct{}{}, err`, - fi.CallMethod, callArgsStr, - ) - } - if len(fi.ReturnParams) > 1 { - return buildMultiReturnMethodBody(fi, callArgsStr, returnType) - } - - return fmt.Sprintf( - `var out []any - err := c.contract.Call(opts, &out, "%s"%s) - if err != nil { - var zero %s - return zero, err - } - return *abi.ConvertType(out[0], new(%s)).(*%s), nil`, - fi.CallMethod, callArgsStr, returnType, returnType, returnType, - ) -} - -// buildMultiReturnMethodBody generates the body for a read method with multiple return values, -// packing them into a result struct. -func buildMultiReturnMethodBody(fi *functionInfo, callArgsStr, returnType string) string { - var b strings.Builder - fmt.Fprintf(&b, "var out []any\n") - fmt.Fprintf(&b, "\terr := c.contract.Call(opts, &out, \"%s\"%s)\n", fi.CallMethod, callArgsStr) - fmt.Fprintf(&b, "\toutstruct := new(%s)\n", returnType) - fmt.Fprintf(&b, "\tif err != nil {\n") - fmt.Fprintf(&b, "\t\treturn *outstruct, err\n") - fmt.Fprintf(&b, "\t}\n\n") - for i, p := range fi.ReturnParams { - fmt.Fprintf(&b, "\toutstruct.%s = *abi.ConvertType(out[%d], new(%s)).(*%s)\n", - fieldNameOrIndex(p.Name, i), i, p.GoType, p.GoType) - } - fmt.Fprintf(&b, "\n\treturn *outstruct, nil") - - return b.String() -} - -// ---- ABI parsing ---- - -// ABIEntry represents a single entry in a Solidity contract ABI JSON. -type ABIEntry struct { - Type string `json:"type"` - Name string `json:"name"` - Inputs []ABIParam `json:"inputs"` - Outputs []ABIParam `json:"outputs"` - StateMutability string `json:"stateMutability"` -} - -// ABIParam represents a parameter within an ABI entry. -type ABIParam struct { - Name string `json:"name"` - Type string `json:"type"` - InternalType string `json:"internalType"` - Components []ABIParam `json:"components"` -} - -// readABIAndBytecode reads the ABI JSON and (optionally) bytecode for a contract -// from the configured input roots: -// -// {input.ABIBasePath}/{versionPath}/{name}.json -// {input.BytecodeBasePath}/{versionPath}/{name}.bin -func readABIAndBytecode( - cfg evmContractConfig, - packageName, - versionPath string, - input evmInputConfig) (abiString string, bytecode string, err error) { - var abiFileName string - if cfg.ABIFile != "" { - if !strings.HasSuffix(cfg.ABIFile, ".json") { - return "", "", fmt.Errorf("abi_file %q must end with .json", cfg.ABIFile) - } - abiFileName = cfg.ABIFile - } else { - abiFileName = packageName + ".json" - } - - abiPath := filepath.Join(input.ABIBasePath, versionPath, abiFileName) - abiBytes, err := os.ReadFile(abiPath) - if err != nil { - return "", "", fmt.Errorf("failed to read ABI from %s: %w", abiPath, err) - } - - if cfg.OmitDeploy { - return string(abiBytes), "", nil - } - - bytecodeName := strings.TrimSuffix(abiFileName, ".json") + ".bin" - bytecodePath := filepath.Join(input.BytecodeBasePath, versionPath, bytecodeName) - bytecodeBytes, err := os.ReadFile(bytecodePath) - if err != nil { - return "", "", fmt.Errorf("failed to read bytecode from %s: %w", bytecodePath, err) - } - - return string(abiBytes), strings.TrimSpace(string(bytecodeBytes)), nil -} - -func extractConstructor(info *contractInfo, abiEntries []ABIEntry, typeMap map[string]string) { - for _, entry := range abiEntries { - if entry.Type == abiTypeConstructor { - info.Constructor = parseABIFunction(entry, info.PackageName, typeMap) - break - } - } -} - -func extractFunctions(info *contractInfo, funcConfigs []evmFunctionConfig, abiEntries []ABIEntry, typeMap map[string]string) error { - for _, funcCfg := range funcConfigs { - funcInfos := findFunctionInABI(abiEntries, funcCfg.Name, info.PackageName, typeMap) - if funcInfos == nil { - return fmt.Errorf("function %s not found in ABI", funcCfg.Name) - } - - for _, fi := range funcInfos { - switch funcCfg.Access { - case accessOwner: - fi.HasOnlyOwner = true - case accessPublic, "": - fi.HasOnlyOwner = false - default: - return fmt.Errorf("unknown access control '%s' for function %s (use 'owner' or 'public')", - funcCfg.Access, funcCfg.Name) - } - - info.Functions[fi.Name] = fi - info.FunctionOrder = append(info.FunctionOrder, fi.Name) - } - } - - return nil -} - -// findFunctionInABI finds all overloads of a function by name and returns functionInfo -// for each, following Geth's overload naming convention. -func findFunctionInABI(entries []ABIEntry, funcName string, packageName string, typeMap map[string]string) []*functionInfo { - var candidates []ABIEntry - for _, entry := range entries { - if entry.Type == abiTypeFunction && strings.EqualFold(entry.Name, funcName) { - candidates = append(candidates, entry) - } - } - - if len(candidates) == 0 { - return nil - } - - var funcInfos []*functionInfo - for i, candidate := range candidates { - fi := parseABIFunction(candidate, packageName, typeMap) - - // Follow Geth's overload naming convention: - // First: no suffix, second: "0", third: "1", etc. - if len(candidates) > 1 && i > 0 { - suffix := strconv.Itoa(i - 1) - fi.Name = fi.Name + suffix - fi.CallMethod = fi.CallMethod + suffix - } - - funcInfos = append(funcInfos, fi) - } - - return funcInfos -} - -// parseABIFunction converts a Solidity ABI function entry into a functionInfo. -// IsWrite is determined by stateMutability: anything other than "view" or "pure" is a write. -func parseABIFunction(entry ABIEntry, packageName string, typeMap map[string]string) *functionInfo { - fi := &functionInfo{ - Name: core.Capitalize(entry.Name), - CallMethod: entry.Name, - IsWrite: entry.StateMutability != stateMutabilityView && entry.StateMutability != stateMutabilityPure, - } - - for i, input := range entry.Inputs { - p := parseABIParam(input, packageName, typeMap) - if p.Name == "" { - p.Name = fmt.Sprintf("arg%d", i) - } - fi.Parameters = append(fi.Parameters, p) - } - - for i, output := range entry.Outputs { - p := parseABIParam(output, packageName, typeMap) - if p.Name == "" { - p.Name = fmt.Sprintf("ret%d", i) - } - fi.ReturnParams = append(fi.ReturnParams, p) - } - - return fi -} - -//nolint:unparam -func parseABIParam(param ABIParam, packageName string, typeMap map[string]string) parameterInfo { - goType := solidityToGoType(param.Type, typeMap) - - pi := parameterInfo{ - Name: param.Name, - SolidityType: param.Type, - GoType: goType, - } - - if strings.HasPrefix(param.Type, "tuple") { - structName := extractStructName(param.InternalType) - if structName != "" { - pi.IsStruct = true - pi.StructName = structName - - if strings.HasSuffix(param.Type, "[]") { - pi.GoType = "[]" + structName - } else { - pi.GoType = structName - } - - for _, comp := range param.Components { - pi.Components = append(pi.Components, parseABIParam(comp, packageName, typeMap)) - } - } - } - - return pi -} - -// solidityToGoType maps a Solidity type string to its Go equivalent using typeMap. -func solidityToGoType(solidityType string, typeMap map[string]string) string { - // Array: uint8[] → []uint8, uint8[32] → [32]uint8 - if i := strings.LastIndexByte(solidityType, '['); i != -1 { - // Guard malformed type strings like "[" or "uint8[" to avoid slicing panics. - if !strings.HasSuffix(solidityType, "]") || i+1 > len(solidityType)-1 { - return anyType - } - sizeStr := solidityType[i+1 : len(solidityType)-1] - _, numErr := strconv.Atoi(sizeStr) - if sizeStr == "" || numErr == nil { - inner := solidityToGoType(solidityType[:i], typeMap) - if inner != anyType { - return "[" + sizeStr + "]" + inner - } - - return anyType - } - } - if goType, ok := typeMap[solidityType]; ok { - return goType - } - - return anyType -} - -// extractStructName parses the Go struct name from a Solidity ABI internalType field. -// e.g. "struct IOnRamp.DestChainConfig" → "DestChainConfig" -// e.g. "struct MyStruct" → "MyStruct" (no module prefix) -// Returns "" for anonymous tuples ("tuple", "tuple[]") so callers fall back to any. -func extractStructName(internalType string) string { - if internalType == "" { - return "" - } - - // Bare "tuple" / "tuple[]" have no named struct — callers should fall back to any. - if strings.HasPrefix(internalType, "tuple") { - return "" - } - - normalized := strings.TrimPrefix(internalType, "struct ") - normalized = strings.TrimSuffix(normalized, "[]") - parts := strings.Split(normalized, ".") - - return parts[len(parts)-1] -} - -// parseABIEntries unmarshals a raw ABI JSON string into a slice of ABIEntry. -func parseABIEntries(abiString string) ([]ABIEntry, error) { - var entries []ABIEntry - if err := json.Unmarshal([]byte(abiString), &entries); err != nil { - return nil, fmt.Errorf("failed to parse ABI: %w", err) - } - - return entries, nil -} - -// checkNeedsBigInt reports whether any parameter in the contract uses *big.Int, -// which requires importing "math/big" in the generated file. -func checkNeedsBigInt(info *contractInfo) bool { - var check func(params []parameterInfo) bool - check = func(params []parameterInfo) bool { - for _, p := range params { - if strings.Contains(p.GoType, "*big.Int") { - return true - } - if len(p.Components) > 0 && check(p.Components) { - return true - } - } - - return false - } - - for _, fi := range info.Functions { - if check(fi.Parameters) || check(fi.ReturnParams) { - return true - } - } - - if info.Constructor != nil && check(info.Constructor.Parameters) { - return true - } - - return false -} - -// ---- Naming utilities ---- - -// trimUnderscores strips all leading underscores from s. -func trimUnderscores(s string) string { - return strings.TrimLeft(s, "_") -} - -// sanitizeFieldName strips leading underscores and capitalizes the result, -// producing a valid exported Go identifier for struct fields. -// Returns "" when the result would start with a digit (e.g. "_1" → ""); callers fall back to "Field%d". -// e.g. "_to" → "To", "_value" → "Value", "balance" → "Balance" -func sanitizeFieldName(name string) string { - trimmed := trimUnderscores(name) - if len(trimmed) == 0 || (trimmed[0] >= '0' && trimmed[0] <= '9') { - return "" - } - - return core.Capitalize(trimmed) -} - -// sanitizeParamName strips leading underscores and lowercases the first rune, -// producing a valid unexported Go identifier for method parameters. -// Returns "" when the result would start with a digit (e.g. "_1" → ""); callers fall back to "arg%d". -// e.g. "_to" → "to", "_value" → "value" -func sanitizeParamName(name string) string { - name = trimUnderscores(name) - if len(name) == 0 || (name[0] >= '0' && name[0] <= '9') { - return "" - } - - return strings.ToLower(name[:1]) + name[1:] -} - -// fieldNameOrIndex returns the sanitized exported field name for a struct field, -// or "Field{i}" when the sanitized result would be empty (e.g. numeric-only names). -func fieldNameOrIndex(name string, i int) string { - if n := sanitizeFieldName(name); n != "" { - return n - } - - return fmt.Sprintf("Field%d", i) -} - -func toSnakeCase(s string) string { - var result []rune - runes := []rune(s) - for i := range runes { - r := runes[i] - if i > 0 && r >= 'A' && r <= 'Z' { - prevLower := runes[i-1] >= 'a' && runes[i-1] <= 'z' - nextLower := i+1 < len(runes) && runes[i+1] >= 'a' && runes[i+1] <= 'z' - if prevLower || nextLower { - result = append(result, '_') - } - } - result = append(result, r) - } - - return strings.ToLower(string(result)) -} - -func toKebabCase(s string) string { - return strings.ReplaceAll(toSnakeCase(s), "_", "-") -} - -// validatePathSegment rejects values that could traverse outside the output base path. -// Absolute paths and any cleaned path containing ".." or a path separator are rejected. -func validatePathSegment(field, value string) error { - if filepath.IsAbs(value) { - return fmt.Errorf("%s must not be an absolute path: %q", field, value) - } - cleaned := filepath.Clean(value) - if strings.Contains(cleaned, "..") || strings.ContainsRune(cleaned, filepath.Separator) { - return fmt.Errorf("%s must not contain path separators or '..': %q", field, value) - } - - return nil -} diff --git a/tools/operations-gen/internal/families/evm/evm_golden_test.go b/tools/operations-gen/internal/families/evm/evm_golden_test.go index 88c326dc0..1634c8b9b 100644 --- a/tools/operations-gen/internal/families/evm/evm_golden_test.go +++ b/tools/operations-gen/internal/families/evm/evm_golden_test.go @@ -1,4 +1,4 @@ -package evm +package evm_test import ( "flag" @@ -10,6 +10,7 @@ import ( "gopkg.in/yaml.v3" "github.com/smartcontractkit/chainlink-deployments-framework/tools/operations-gen/internal/core" + "github.com/smartcontractkit/chainlink-deployments-framework/tools/operations-gen/internal/families/evm" ) var update = flag.Bool("update", false, "update golden files") @@ -46,15 +47,15 @@ func runGoldenGenerationTest(t *testing.T, configFileName string, goldenFileName } // Override paths: inputs point to fixture dirs, output to a temp dir. - cfg.Input = mustYAMLNode(t, evmInputConfig{ + cfg.Input = mustYAMLNode(t, evm.EvmInputConfig{ ABIBasePath: filepath.Join(evmTestdataDir, "abi"), BytecodeBasePath: filepath.Join(evmTestdataDir, "bytecode"), }) tmpDir := t.TempDir() - cfg.Output = mustYAMLNode(t, evmOutputConfig{BasePath: tmpDir}) + cfg.Output = mustYAMLNode(t, evm.EvmOutputConfig{BasePath: tmpDir}) cfg.ConfigDir = "" - handler := Handler{} + handler := evm.Handler{} tmpl, err := loadTemplateForTest() if err != nil { t.Fatalf("loadTemplate: %v", err) @@ -65,14 +66,14 @@ func runGoldenGenerationTest(t *testing.T, configFileName string, goldenFileName } // Derive the output path from the first contract in the config, mirroring extractContractInfo. - var contractCfgs []evmContractConfig + var contractCfgs []evm.EvmContractConfig if err = cfg.Contracts.Decode(&contractCfgs); err != nil || len(contractCfgs) == 0 { t.Fatalf("decoding contract configs: %v", err) } first := contractCfgs[0] pkgName := first.PackageName if pkgName == "" { - pkgName = toSnakeCase(first.Name) + pkgName = evm.ToSnakeCase(first.Name) } vPath := core.VersionToPath(first.Version) if first.VersionPath != "" { diff --git a/tools/operations-gen/testdata/evm/gobindings/v1_0_0/link_token/link_token.go b/tools/operations-gen/testdata/evm/gobindings/v1_0_0/link_token/link_token.go new file mode 100644 index 000000000..95ef74617 --- /dev/null +++ b/tools/operations-gen/testdata/evm/gobindings/v1_0_0/link_token/link_token.go @@ -0,0 +1,2038 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package link_token + +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" +) + +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +var LinkTokenMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"constructor\",\"inputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"acceptOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"allowance\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"approve\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"balanceOf\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"burn\",\"inputs\":[{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"burn\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"burnFrom\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"decimals\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"subtractedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"decreaseApproval\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"subtractedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"success\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getBurners\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMinters\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"grantBurnRole\",\"inputs\":[{\"name\":\"burner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"grantMintAndBurnRoles\",\"inputs\":[{\"name\":\"burnAndMinter\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"grantMintRole\",\"inputs\":[{\"name\":\"minter\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"increaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"addedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"increaseApproval\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"addedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isBurner\",\"inputs\":[{\"name\":\"burner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isMinter\",\"inputs\":[{\"name\":\"minter\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxSupply\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"mint\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"name\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"revokeBurnRole\",\"inputs\":[{\"name\":\"burner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"revokeMintRole\",\"inputs\":[{\"name\":\"minter\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"supportsInterface\",\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"symbol\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalSupply\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transfer\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferAndCall\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"success\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Approval\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BurnAccessGranted\",\"inputs\":[{\"name\":\"burner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BurnAccessRevoked\",\"inputs\":[{\"name\":\"burner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MintAccessGranted\",\"inputs\":[{\"name\":\"minter\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MintAccessRevoked\",\"inputs\":[{\"name\":\"minter\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferRequested\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Transfer\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Transfer\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"MaxSupplyExceeded\",\"inputs\":[{\"name\":\"supplyAfterMint\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"SenderNotBurner\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"SenderNotMinter\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]}]", + Bin: "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", +} + +var LinkTokenABI = LinkTokenMetaData.ABI + +var LinkTokenBin = LinkTokenMetaData.Bin + +func DeployLinkToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *LinkToken, error) { + parsed, err := LinkTokenMetaData.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(LinkTokenBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &LinkToken{address: address, abi: *parsed, LinkTokenCaller: LinkTokenCaller{contract: contract}, LinkTokenTransactor: LinkTokenTransactor{contract: contract}, LinkTokenFilterer: LinkTokenFilterer{contract: contract}}, nil +} + +type LinkToken struct { + address common.Address + abi abi.ABI + LinkTokenCaller + LinkTokenTransactor + LinkTokenFilterer +} + +type LinkTokenCaller struct { + contract *bind.BoundContract +} + +type LinkTokenTransactor struct { + contract *bind.BoundContract +} + +type LinkTokenFilterer struct { + contract *bind.BoundContract +} + +type LinkTokenSession struct { + Contract *LinkToken + CallOpts bind.CallOpts + TransactOpts bind.TransactOpts +} + +type LinkTokenCallerSession struct { + Contract *LinkTokenCaller + CallOpts bind.CallOpts +} + +type LinkTokenTransactorSession struct { + Contract *LinkTokenTransactor + TransactOpts bind.TransactOpts +} + +type LinkTokenRaw struct { + Contract *LinkToken +} + +type LinkTokenCallerRaw struct { + Contract *LinkTokenCaller +} + +type LinkTokenTransactorRaw struct { + Contract *LinkTokenTransactor +} + +func NewLinkToken(address common.Address, backend bind.ContractBackend) (*LinkToken, error) { + abi, err := abi.JSON(strings.NewReader(LinkTokenABI)) + if err != nil { + return nil, err + } + contract, err := bindLinkToken(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &LinkToken{address: address, abi: abi, LinkTokenCaller: LinkTokenCaller{contract: contract}, LinkTokenTransactor: LinkTokenTransactor{contract: contract}, LinkTokenFilterer: LinkTokenFilterer{contract: contract}}, nil +} + +func NewLinkTokenCaller(address common.Address, caller bind.ContractCaller) (*LinkTokenCaller, error) { + contract, err := bindLinkToken(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &LinkTokenCaller{contract: contract}, nil +} + +func NewLinkTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*LinkTokenTransactor, error) { + contract, err := bindLinkToken(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &LinkTokenTransactor{contract: contract}, nil +} + +func NewLinkTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*LinkTokenFilterer, error) { + contract, err := bindLinkToken(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &LinkTokenFilterer{contract: contract}, nil +} + +func bindLinkToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := LinkTokenMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +func (_LinkToken *LinkTokenRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _LinkToken.Contract.LinkTokenCaller.contract.Call(opts, result, method, params...) +} + +func (_LinkToken *LinkTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _LinkToken.Contract.LinkTokenTransactor.contract.Transfer(opts) +} + +func (_LinkToken *LinkTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _LinkToken.Contract.LinkTokenTransactor.contract.Transact(opts, method, params...) +} + +func (_LinkToken *LinkTokenCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _LinkToken.Contract.contract.Call(opts, result, method, params...) +} + +func (_LinkToken *LinkTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _LinkToken.Contract.contract.Transfer(opts) +} + +func (_LinkToken *LinkTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _LinkToken.Contract.contract.Transact(opts, method, params...) +} + +func (_LinkToken *LinkTokenCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "allowance", owner, spender) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _LinkToken.Contract.Allowance(&_LinkToken.CallOpts, owner, spender) +} + +func (_LinkToken *LinkTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _LinkToken.Contract.Allowance(&_LinkToken.CallOpts, owner, spender) +} + +func (_LinkToken *LinkTokenCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "balanceOf", account) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) BalanceOf(account common.Address) (*big.Int, error) { + return _LinkToken.Contract.BalanceOf(&_LinkToken.CallOpts, account) +} + +func (_LinkToken *LinkTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _LinkToken.Contract.BalanceOf(&_LinkToken.CallOpts, account) +} + +func (_LinkToken *LinkTokenCaller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) Decimals() (uint8, error) { + return _LinkToken.Contract.Decimals(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCallerSession) Decimals() (uint8, error) { + return _LinkToken.Contract.Decimals(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCaller) GetBurners(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "getBurners") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) GetBurners() ([]common.Address, error) { + return _LinkToken.Contract.GetBurners(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCallerSession) GetBurners() ([]common.Address, error) { + return _LinkToken.Contract.GetBurners(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCaller) GetMinters(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "getMinters") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) GetMinters() ([]common.Address, error) { + return _LinkToken.Contract.GetMinters(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCallerSession) GetMinters() ([]common.Address, error) { + return _LinkToken.Contract.GetMinters(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCaller) IsBurner(opts *bind.CallOpts, burner common.Address) (bool, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "isBurner", burner) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) IsBurner(burner common.Address) (bool, error) { + return _LinkToken.Contract.IsBurner(&_LinkToken.CallOpts, burner) +} + +func (_LinkToken *LinkTokenCallerSession) IsBurner(burner common.Address) (bool, error) { + return _LinkToken.Contract.IsBurner(&_LinkToken.CallOpts, burner) +} + +func (_LinkToken *LinkTokenCaller) IsMinter(opts *bind.CallOpts, minter common.Address) (bool, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "isMinter", minter) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) IsMinter(minter common.Address) (bool, error) { + return _LinkToken.Contract.IsMinter(&_LinkToken.CallOpts, minter) +} + +func (_LinkToken *LinkTokenCallerSession) IsMinter(minter common.Address) (bool, error) { + return _LinkToken.Contract.IsMinter(&_LinkToken.CallOpts, minter) +} + +func (_LinkToken *LinkTokenCaller) MaxSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "maxSupply") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) MaxSupply() (*big.Int, error) { + return _LinkToken.Contract.MaxSupply(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCallerSession) MaxSupply() (*big.Int, error) { + return _LinkToken.Contract.MaxSupply(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCaller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) Name() (string, error) { + return _LinkToken.Contract.Name(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCallerSession) Name() (string, error) { + return _LinkToken.Contract.Name(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _LinkToken.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 + +} + +func (_LinkToken *LinkTokenSession) Owner() (common.Address, error) { + return _LinkToken.Contract.Owner(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCallerSession) Owner() (common.Address, error) { + return _LinkToken.Contract.Owner(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "supportsInterface", interfaceId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _LinkToken.Contract.SupportsInterface(&_LinkToken.CallOpts, interfaceId) +} + +func (_LinkToken *LinkTokenCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _LinkToken.Contract.SupportsInterface(&_LinkToken.CallOpts, interfaceId) +} + +func (_LinkToken *LinkTokenCaller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) Symbol() (string, error) { + return _LinkToken.Contract.Symbol(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCallerSession) Symbol() (string, error) { + return _LinkToken.Contract.Symbol(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _LinkToken.contract.Call(opts, &out, "totalSupply") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_LinkToken *LinkTokenSession) TotalSupply() (*big.Int, error) { + return _LinkToken.Contract.TotalSupply(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenCallerSession) TotalSupply() (*big.Int, error) { + return _LinkToken.Contract.TotalSupply(&_LinkToken.CallOpts) +} + +func (_LinkToken *LinkTokenTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "acceptOwnership") +} + +func (_LinkToken *LinkTokenSession) AcceptOwnership() (*types.Transaction, error) { + return _LinkToken.Contract.AcceptOwnership(&_LinkToken.TransactOpts) +} + +func (_LinkToken *LinkTokenTransactorSession) AcceptOwnership() (*types.Transaction, error) { + return _LinkToken.Contract.AcceptOwnership(&_LinkToken.TransactOpts) +} + +func (_LinkToken *LinkTokenTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "approve", spender, amount) +} + +func (_LinkToken *LinkTokenSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Approve(&_LinkToken.TransactOpts, spender, amount) +} + +func (_LinkToken *LinkTokenTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Approve(&_LinkToken.TransactOpts, spender, amount) +} + +func (_LinkToken *LinkTokenTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "burn", amount) +} + +func (_LinkToken *LinkTokenSession) Burn(amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Burn(&_LinkToken.TransactOpts, amount) +} + +func (_LinkToken *LinkTokenTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Burn(&_LinkToken.TransactOpts, amount) +} + +func (_LinkToken *LinkTokenTransactor) Burn0(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "burn0", account, amount) +} + +func (_LinkToken *LinkTokenSession) Burn0(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Burn0(&_LinkToken.TransactOpts, account, amount) +} + +func (_LinkToken *LinkTokenTransactorSession) Burn0(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Burn0(&_LinkToken.TransactOpts, account, amount) +} + +func (_LinkToken *LinkTokenTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "burnFrom", account, amount) +} + +func (_LinkToken *LinkTokenSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.BurnFrom(&_LinkToken.TransactOpts, account, amount) +} + +func (_LinkToken *LinkTokenTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.BurnFrom(&_LinkToken.TransactOpts, account, amount) +} + +func (_LinkToken *LinkTokenTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) +} + +func (_LinkToken *LinkTokenSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.DecreaseAllowance(&_LinkToken.TransactOpts, spender, subtractedValue) +} + +func (_LinkToken *LinkTokenTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.DecreaseAllowance(&_LinkToken.TransactOpts, spender, subtractedValue) +} + +func (_LinkToken *LinkTokenTransactor) DecreaseApproval(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "decreaseApproval", spender, subtractedValue) +} + +func (_LinkToken *LinkTokenSession) DecreaseApproval(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.DecreaseApproval(&_LinkToken.TransactOpts, spender, subtractedValue) +} + +func (_LinkToken *LinkTokenTransactorSession) DecreaseApproval(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.DecreaseApproval(&_LinkToken.TransactOpts, spender, subtractedValue) +} + +func (_LinkToken *LinkTokenTransactor) GrantBurnRole(opts *bind.TransactOpts, burner common.Address) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "grantBurnRole", burner) +} + +func (_LinkToken *LinkTokenSession) GrantBurnRole(burner common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.GrantBurnRole(&_LinkToken.TransactOpts, burner) +} + +func (_LinkToken *LinkTokenTransactorSession) GrantBurnRole(burner common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.GrantBurnRole(&_LinkToken.TransactOpts, burner) +} + +func (_LinkToken *LinkTokenTransactor) GrantMintAndBurnRoles(opts *bind.TransactOpts, burnAndMinter common.Address) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "grantMintAndBurnRoles", burnAndMinter) +} + +func (_LinkToken *LinkTokenSession) GrantMintAndBurnRoles(burnAndMinter common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.GrantMintAndBurnRoles(&_LinkToken.TransactOpts, burnAndMinter) +} + +func (_LinkToken *LinkTokenTransactorSession) GrantMintAndBurnRoles(burnAndMinter common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.GrantMintAndBurnRoles(&_LinkToken.TransactOpts, burnAndMinter) +} + +func (_LinkToken *LinkTokenTransactor) GrantMintRole(opts *bind.TransactOpts, minter common.Address) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "grantMintRole", minter) +} + +func (_LinkToken *LinkTokenSession) GrantMintRole(minter common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.GrantMintRole(&_LinkToken.TransactOpts, minter) +} + +func (_LinkToken *LinkTokenTransactorSession) GrantMintRole(minter common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.GrantMintRole(&_LinkToken.TransactOpts, minter) +} + +func (_LinkToken *LinkTokenTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "increaseAllowance", spender, addedValue) +} + +func (_LinkToken *LinkTokenSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.IncreaseAllowance(&_LinkToken.TransactOpts, spender, addedValue) +} + +func (_LinkToken *LinkTokenTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.IncreaseAllowance(&_LinkToken.TransactOpts, spender, addedValue) +} + +func (_LinkToken *LinkTokenTransactor) IncreaseApproval(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "increaseApproval", spender, addedValue) +} + +func (_LinkToken *LinkTokenSession) IncreaseApproval(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.IncreaseApproval(&_LinkToken.TransactOpts, spender, addedValue) +} + +func (_LinkToken *LinkTokenTransactorSession) IncreaseApproval(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.IncreaseApproval(&_LinkToken.TransactOpts, spender, addedValue) +} + +func (_LinkToken *LinkTokenTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "mint", account, amount) +} + +func (_LinkToken *LinkTokenSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Mint(&_LinkToken.TransactOpts, account, amount) +} + +func (_LinkToken *LinkTokenTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Mint(&_LinkToken.TransactOpts, account, amount) +} + +func (_LinkToken *LinkTokenTransactor) RevokeBurnRole(opts *bind.TransactOpts, burner common.Address) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "revokeBurnRole", burner) +} + +func (_LinkToken *LinkTokenSession) RevokeBurnRole(burner common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.RevokeBurnRole(&_LinkToken.TransactOpts, burner) +} + +func (_LinkToken *LinkTokenTransactorSession) RevokeBurnRole(burner common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.RevokeBurnRole(&_LinkToken.TransactOpts, burner) +} + +func (_LinkToken *LinkTokenTransactor) RevokeMintRole(opts *bind.TransactOpts, minter common.Address) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "revokeMintRole", minter) +} + +func (_LinkToken *LinkTokenSession) RevokeMintRole(minter common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.RevokeMintRole(&_LinkToken.TransactOpts, minter) +} + +func (_LinkToken *LinkTokenTransactorSession) RevokeMintRole(minter common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.RevokeMintRole(&_LinkToken.TransactOpts, minter) +} + +func (_LinkToken *LinkTokenTransactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "transfer", to, amount) +} + +func (_LinkToken *LinkTokenSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Transfer(&_LinkToken.TransactOpts, to, amount) +} + +func (_LinkToken *LinkTokenTransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.Transfer(&_LinkToken.TransactOpts, to, amount) +} + +func (_LinkToken *LinkTokenTransactor) TransferAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "transferAndCall", to, amount, data) +} + +func (_LinkToken *LinkTokenSession) TransferAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _LinkToken.Contract.TransferAndCall(&_LinkToken.TransactOpts, to, amount, data) +} + +func (_LinkToken *LinkTokenTransactorSession) TransferAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _LinkToken.Contract.TransferAndCall(&_LinkToken.TransactOpts, to, amount, data) +} + +func (_LinkToken *LinkTokenTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "transferFrom", from, to, amount) +} + +func (_LinkToken *LinkTokenSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.TransferFrom(&_LinkToken.TransactOpts, from, to, amount) +} + +func (_LinkToken *LinkTokenTransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _LinkToken.Contract.TransferFrom(&_LinkToken.TransactOpts, from, to, amount) +} + +func (_LinkToken *LinkTokenTransactor) TransferOwnership(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error) { + return _LinkToken.contract.Transact(opts, "transferOwnership", to) +} + +func (_LinkToken *LinkTokenSession) TransferOwnership(to common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.TransferOwnership(&_LinkToken.TransactOpts, to) +} + +func (_LinkToken *LinkTokenTransactorSession) TransferOwnership(to common.Address) (*types.Transaction, error) { + return _LinkToken.Contract.TransferOwnership(&_LinkToken.TransactOpts, to) +} + +type LinkTokenApprovalIterator struct { + Event *LinkTokenApproval + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *LinkTokenApprovalIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(LinkTokenApproval) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(LinkTokenApproval) + 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() + } +} + +func (it *LinkTokenApprovalIterator) Error() error { + return it.fail +} + +func (it *LinkTokenApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type LinkTokenApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log +} + +func (_LinkToken *LinkTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*LinkTokenApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _LinkToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &LinkTokenApprovalIterator{contract: _LinkToken.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +func (_LinkToken *LinkTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *LinkTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _LinkToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(LinkTokenApproval) + if err := _LinkToken.contract.UnpackLog(event, "Approval", 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 +} + +func (_LinkToken *LinkTokenFilterer) ParseApproval(log types.Log) (*LinkTokenApproval, error) { + event := new(LinkTokenApproval) + if err := _LinkToken.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type LinkTokenBurnAccessGrantedIterator struct { + Event *LinkTokenBurnAccessGranted + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *LinkTokenBurnAccessGrantedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(LinkTokenBurnAccessGranted) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(LinkTokenBurnAccessGranted) + 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() + } +} + +func (it *LinkTokenBurnAccessGrantedIterator) Error() error { + return it.fail +} + +func (it *LinkTokenBurnAccessGrantedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type LinkTokenBurnAccessGranted struct { + Burner common.Address + Raw types.Log +} + +func (_LinkToken *LinkTokenFilterer) FilterBurnAccessGranted(opts *bind.FilterOpts, burner []common.Address) (*LinkTokenBurnAccessGrantedIterator, error) { + + var burnerRule []interface{} + for _, burnerItem := range burner { + burnerRule = append(burnerRule, burnerItem) + } + + logs, sub, err := _LinkToken.contract.FilterLogs(opts, "BurnAccessGranted", burnerRule) + if err != nil { + return nil, err + } + return &LinkTokenBurnAccessGrantedIterator{contract: _LinkToken.contract, event: "BurnAccessGranted", logs: logs, sub: sub}, nil +} + +func (_LinkToken *LinkTokenFilterer) WatchBurnAccessGranted(opts *bind.WatchOpts, sink chan<- *LinkTokenBurnAccessGranted, burner []common.Address) (event.Subscription, error) { + + var burnerRule []interface{} + for _, burnerItem := range burner { + burnerRule = append(burnerRule, burnerItem) + } + + logs, sub, err := _LinkToken.contract.WatchLogs(opts, "BurnAccessGranted", burnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(LinkTokenBurnAccessGranted) + if err := _LinkToken.contract.UnpackLog(event, "BurnAccessGranted", 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 +} + +func (_LinkToken *LinkTokenFilterer) ParseBurnAccessGranted(log types.Log) (*LinkTokenBurnAccessGranted, error) { + event := new(LinkTokenBurnAccessGranted) + if err := _LinkToken.contract.UnpackLog(event, "BurnAccessGranted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type LinkTokenBurnAccessRevokedIterator struct { + Event *LinkTokenBurnAccessRevoked + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *LinkTokenBurnAccessRevokedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(LinkTokenBurnAccessRevoked) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(LinkTokenBurnAccessRevoked) + 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() + } +} + +func (it *LinkTokenBurnAccessRevokedIterator) Error() error { + return it.fail +} + +func (it *LinkTokenBurnAccessRevokedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type LinkTokenBurnAccessRevoked struct { + Burner common.Address + Raw types.Log +} + +func (_LinkToken *LinkTokenFilterer) FilterBurnAccessRevoked(opts *bind.FilterOpts, burner []common.Address) (*LinkTokenBurnAccessRevokedIterator, error) { + + var burnerRule []interface{} + for _, burnerItem := range burner { + burnerRule = append(burnerRule, burnerItem) + } + + logs, sub, err := _LinkToken.contract.FilterLogs(opts, "BurnAccessRevoked", burnerRule) + if err != nil { + return nil, err + } + return &LinkTokenBurnAccessRevokedIterator{contract: _LinkToken.contract, event: "BurnAccessRevoked", logs: logs, sub: sub}, nil +} + +func (_LinkToken *LinkTokenFilterer) WatchBurnAccessRevoked(opts *bind.WatchOpts, sink chan<- *LinkTokenBurnAccessRevoked, burner []common.Address) (event.Subscription, error) { + + var burnerRule []interface{} + for _, burnerItem := range burner { + burnerRule = append(burnerRule, burnerItem) + } + + logs, sub, err := _LinkToken.contract.WatchLogs(opts, "BurnAccessRevoked", burnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(LinkTokenBurnAccessRevoked) + if err := _LinkToken.contract.UnpackLog(event, "BurnAccessRevoked", 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 +} + +func (_LinkToken *LinkTokenFilterer) ParseBurnAccessRevoked(log types.Log) (*LinkTokenBurnAccessRevoked, error) { + event := new(LinkTokenBurnAccessRevoked) + if err := _LinkToken.contract.UnpackLog(event, "BurnAccessRevoked", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type LinkTokenMintAccessGrantedIterator struct { + Event *LinkTokenMintAccessGranted + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *LinkTokenMintAccessGrantedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(LinkTokenMintAccessGranted) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(LinkTokenMintAccessGranted) + 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() + } +} + +func (it *LinkTokenMintAccessGrantedIterator) Error() error { + return it.fail +} + +func (it *LinkTokenMintAccessGrantedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type LinkTokenMintAccessGranted struct { + Minter common.Address + Raw types.Log +} + +func (_LinkToken *LinkTokenFilterer) FilterMintAccessGranted(opts *bind.FilterOpts, minter []common.Address) (*LinkTokenMintAccessGrantedIterator, error) { + + var minterRule []interface{} + for _, minterItem := range minter { + minterRule = append(minterRule, minterItem) + } + + logs, sub, err := _LinkToken.contract.FilterLogs(opts, "MintAccessGranted", minterRule) + if err != nil { + return nil, err + } + return &LinkTokenMintAccessGrantedIterator{contract: _LinkToken.contract, event: "MintAccessGranted", logs: logs, sub: sub}, nil +} + +func (_LinkToken *LinkTokenFilterer) WatchMintAccessGranted(opts *bind.WatchOpts, sink chan<- *LinkTokenMintAccessGranted, minter []common.Address) (event.Subscription, error) { + + var minterRule []interface{} + for _, minterItem := range minter { + minterRule = append(minterRule, minterItem) + } + + logs, sub, err := _LinkToken.contract.WatchLogs(opts, "MintAccessGranted", minterRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(LinkTokenMintAccessGranted) + if err := _LinkToken.contract.UnpackLog(event, "MintAccessGranted", 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 +} + +func (_LinkToken *LinkTokenFilterer) ParseMintAccessGranted(log types.Log) (*LinkTokenMintAccessGranted, error) { + event := new(LinkTokenMintAccessGranted) + if err := _LinkToken.contract.UnpackLog(event, "MintAccessGranted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type LinkTokenMintAccessRevokedIterator struct { + Event *LinkTokenMintAccessRevoked + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *LinkTokenMintAccessRevokedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(LinkTokenMintAccessRevoked) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(LinkTokenMintAccessRevoked) + 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() + } +} + +func (it *LinkTokenMintAccessRevokedIterator) Error() error { + return it.fail +} + +func (it *LinkTokenMintAccessRevokedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type LinkTokenMintAccessRevoked struct { + Minter common.Address + Raw types.Log +} + +func (_LinkToken *LinkTokenFilterer) FilterMintAccessRevoked(opts *bind.FilterOpts, minter []common.Address) (*LinkTokenMintAccessRevokedIterator, error) { + + var minterRule []interface{} + for _, minterItem := range minter { + minterRule = append(minterRule, minterItem) + } + + logs, sub, err := _LinkToken.contract.FilterLogs(opts, "MintAccessRevoked", minterRule) + if err != nil { + return nil, err + } + return &LinkTokenMintAccessRevokedIterator{contract: _LinkToken.contract, event: "MintAccessRevoked", logs: logs, sub: sub}, nil +} + +func (_LinkToken *LinkTokenFilterer) WatchMintAccessRevoked(opts *bind.WatchOpts, sink chan<- *LinkTokenMintAccessRevoked, minter []common.Address) (event.Subscription, error) { + + var minterRule []interface{} + for _, minterItem := range minter { + minterRule = append(minterRule, minterItem) + } + + logs, sub, err := _LinkToken.contract.WatchLogs(opts, "MintAccessRevoked", minterRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(LinkTokenMintAccessRevoked) + if err := _LinkToken.contract.UnpackLog(event, "MintAccessRevoked", 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 +} + +func (_LinkToken *LinkTokenFilterer) ParseMintAccessRevoked(log types.Log) (*LinkTokenMintAccessRevoked, error) { + event := new(LinkTokenMintAccessRevoked) + if err := _LinkToken.contract.UnpackLog(event, "MintAccessRevoked", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type LinkTokenOwnershipTransferRequestedIterator struct { + Event *LinkTokenOwnershipTransferRequested + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *LinkTokenOwnershipTransferRequestedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(LinkTokenOwnershipTransferRequested) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(LinkTokenOwnershipTransferRequested) + 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() + } +} + +func (it *LinkTokenOwnershipTransferRequestedIterator) Error() error { + return it.fail +} + +func (it *LinkTokenOwnershipTransferRequestedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type LinkTokenOwnershipTransferRequested struct { + From common.Address + To common.Address + Raw types.Log +} + +func (_LinkToken *LinkTokenFilterer) FilterOwnershipTransferRequested(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LinkTokenOwnershipTransferRequestedIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _LinkToken.contract.FilterLogs(opts, "OwnershipTransferRequested", fromRule, toRule) + if err != nil { + return nil, err + } + return &LinkTokenOwnershipTransferRequestedIterator{contract: _LinkToken.contract, event: "OwnershipTransferRequested", logs: logs, sub: sub}, nil +} + +func (_LinkToken *LinkTokenFilterer) WatchOwnershipTransferRequested(opts *bind.WatchOpts, sink chan<- *LinkTokenOwnershipTransferRequested, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _LinkToken.contract.WatchLogs(opts, "OwnershipTransferRequested", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(LinkTokenOwnershipTransferRequested) + if err := _LinkToken.contract.UnpackLog(event, "OwnershipTransferRequested", 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 +} + +func (_LinkToken *LinkTokenFilterer) ParseOwnershipTransferRequested(log types.Log) (*LinkTokenOwnershipTransferRequested, error) { + event := new(LinkTokenOwnershipTransferRequested) + if err := _LinkToken.contract.UnpackLog(event, "OwnershipTransferRequested", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type LinkTokenOwnershipTransferredIterator struct { + Event *LinkTokenOwnershipTransferred + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *LinkTokenOwnershipTransferredIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(LinkTokenOwnershipTransferred) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(LinkTokenOwnershipTransferred) + 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() + } +} + +func (it *LinkTokenOwnershipTransferredIterator) Error() error { + return it.fail +} + +func (it *LinkTokenOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type LinkTokenOwnershipTransferred struct { + From common.Address + To common.Address + Raw types.Log +} + +func (_LinkToken *LinkTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LinkTokenOwnershipTransferredIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _LinkToken.contract.FilterLogs(opts, "OwnershipTransferred", fromRule, toRule) + if err != nil { + return nil, err + } + return &LinkTokenOwnershipTransferredIterator{contract: _LinkToken.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +func (_LinkToken *LinkTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *LinkTokenOwnershipTransferred, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _LinkToken.contract.WatchLogs(opts, "OwnershipTransferred", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(LinkTokenOwnershipTransferred) + if err := _LinkToken.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 +} + +func (_LinkToken *LinkTokenFilterer) ParseOwnershipTransferred(log types.Log) (*LinkTokenOwnershipTransferred, error) { + event := new(LinkTokenOwnershipTransferred) + if err := _LinkToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type LinkTokenTransferIterator struct { + Event *LinkTokenTransfer + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *LinkTokenTransferIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(LinkTokenTransfer) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(LinkTokenTransfer) + 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() + } +} + +func (it *LinkTokenTransferIterator) Error() error { + return it.fail +} + +func (it *LinkTokenTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type LinkTokenTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log +} + +func (_LinkToken *LinkTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LinkTokenTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _LinkToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &LinkTokenTransferIterator{contract: _LinkToken.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +func (_LinkToken *LinkTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *LinkTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _LinkToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(LinkTokenTransfer) + if err := _LinkToken.contract.UnpackLog(event, "Transfer", 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 +} + +func (_LinkToken *LinkTokenFilterer) ParseTransfer(log types.Log) (*LinkTokenTransfer, error) { + event := new(LinkTokenTransfer) + if err := _LinkToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type LinkTokenTransfer0Iterator struct { + Event *LinkTokenTransfer0 + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *LinkTokenTransfer0Iterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(LinkTokenTransfer0) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(LinkTokenTransfer0) + 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() + } +} + +func (it *LinkTokenTransfer0Iterator) Error() error { + return it.fail +} + +func (it *LinkTokenTransfer0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type LinkTokenTransfer0 struct { + From common.Address + To common.Address + Value *big.Int + Data []byte + Raw types.Log +} + +func (_LinkToken *LinkTokenFilterer) FilterTransfer0(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LinkTokenTransfer0Iterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _LinkToken.contract.FilterLogs(opts, "Transfer0", fromRule, toRule) + if err != nil { + return nil, err + } + return &LinkTokenTransfer0Iterator{contract: _LinkToken.contract, event: "Transfer0", logs: logs, sub: sub}, nil +} + +func (_LinkToken *LinkTokenFilterer) WatchTransfer0(opts *bind.WatchOpts, sink chan<- *LinkTokenTransfer0, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _LinkToken.contract.WatchLogs(opts, "Transfer0", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(LinkTokenTransfer0) + if err := _LinkToken.contract.UnpackLog(event, "Transfer0", 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 +} + +func (_LinkToken *LinkTokenFilterer) ParseTransfer0(log types.Log) (*LinkTokenTransfer0, error) { + event := new(LinkTokenTransfer0) + if err := _LinkToken.contract.UnpackLog(event, "Transfer0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +func (LinkTokenApproval) Topic() common.Hash { + return common.HexToHash("0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925") +} + +func (LinkTokenBurnAccessGranted) Topic() common.Hash { + return common.HexToHash("0x92308bb7573b2a3d17ddb868b39d8ebec433f3194421abc22d084f89658c9bad") +} + +func (LinkTokenBurnAccessRevoked) Topic() common.Hash { + return common.HexToHash("0x0a675452746933cefe3d74182e78db7afe57ba60eaa4234b5d85e9aa41b0610c") +} + +func (LinkTokenMintAccessGranted) Topic() common.Hash { + return common.HexToHash("0xe46fef8bbff1389d9010703cf8ebb363fb3daf5bf56edc27080b67bc8d9251ea") +} + +func (LinkTokenMintAccessRevoked) Topic() common.Hash { + return common.HexToHash("0xed998b960f6340d045f620c119730f7aa7995e7425c2401d3a5b64ff998a59e9") +} + +func (LinkTokenOwnershipTransferRequested) Topic() common.Hash { + return common.HexToHash("0xed8889f560326eb138920d842192f0eb3dd22b4f139c87a2c57538e05bae1278") +} + +func (LinkTokenOwnershipTransferred) Topic() common.Hash { + return common.HexToHash("0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0") +} + +func (LinkTokenTransfer) Topic() common.Hash { + return common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef") +} + +func (LinkTokenTransfer0) Topic() common.Hash { + return common.HexToHash("0xe19260aff97b920c7df27010903aeb9c8d2be5d310a2c67824cf3f15396e4c16") +} + +func (_LinkToken *LinkToken) Address() common.Address { + return _LinkToken.address +} + +type LinkTokenInterface interface { + Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) + + BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) + + Decimals(opts *bind.CallOpts) (uint8, error) + + GetBurners(opts *bind.CallOpts) ([]common.Address, error) + + GetMinters(opts *bind.CallOpts) ([]common.Address, error) + + IsBurner(opts *bind.CallOpts, burner common.Address) (bool, error) + + IsMinter(opts *bind.CallOpts, minter common.Address) (bool, error) + + MaxSupply(opts *bind.CallOpts) (*big.Int, error) + + Name(opts *bind.CallOpts) (string, error) + + Owner(opts *bind.CallOpts) (common.Address, error) + + SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) + + Symbol(opts *bind.CallOpts) (string, error) + + TotalSupply(opts *bind.CallOpts) (*big.Int, error) + + AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) + + Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) + + Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) + + Burn0(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) + + BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) + + DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) + + DecreaseApproval(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) + + GrantBurnRole(opts *bind.TransactOpts, burner common.Address) (*types.Transaction, error) + + GrantMintAndBurnRoles(opts *bind.TransactOpts, burnAndMinter common.Address) (*types.Transaction, error) + + GrantMintRole(opts *bind.TransactOpts, minter common.Address) (*types.Transaction, error) + + IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) + + IncreaseApproval(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) + + Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) + + RevokeBurnRole(opts *bind.TransactOpts, burner common.Address) (*types.Transaction, error) + + RevokeMintRole(opts *bind.TransactOpts, minter common.Address) (*types.Transaction, error) + + Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) + + TransferAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) + + TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) + + TransferOwnership(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error) + + FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*LinkTokenApprovalIterator, error) + + WatchApproval(opts *bind.WatchOpts, sink chan<- *LinkTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) + + ParseApproval(log types.Log) (*LinkTokenApproval, error) + + FilterBurnAccessGranted(opts *bind.FilterOpts, burner []common.Address) (*LinkTokenBurnAccessGrantedIterator, error) + + WatchBurnAccessGranted(opts *bind.WatchOpts, sink chan<- *LinkTokenBurnAccessGranted, burner []common.Address) (event.Subscription, error) + + ParseBurnAccessGranted(log types.Log) (*LinkTokenBurnAccessGranted, error) + + FilterBurnAccessRevoked(opts *bind.FilterOpts, burner []common.Address) (*LinkTokenBurnAccessRevokedIterator, error) + + WatchBurnAccessRevoked(opts *bind.WatchOpts, sink chan<- *LinkTokenBurnAccessRevoked, burner []common.Address) (event.Subscription, error) + + ParseBurnAccessRevoked(log types.Log) (*LinkTokenBurnAccessRevoked, error) + + FilterMintAccessGranted(opts *bind.FilterOpts, minter []common.Address) (*LinkTokenMintAccessGrantedIterator, error) + + WatchMintAccessGranted(opts *bind.WatchOpts, sink chan<- *LinkTokenMintAccessGranted, minter []common.Address) (event.Subscription, error) + + ParseMintAccessGranted(log types.Log) (*LinkTokenMintAccessGranted, error) + + FilterMintAccessRevoked(opts *bind.FilterOpts, minter []common.Address) (*LinkTokenMintAccessRevokedIterator, error) + + WatchMintAccessRevoked(opts *bind.WatchOpts, sink chan<- *LinkTokenMintAccessRevoked, minter []common.Address) (event.Subscription, error) + + ParseMintAccessRevoked(log types.Log) (*LinkTokenMintAccessRevoked, error) + + FilterOwnershipTransferRequested(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LinkTokenOwnershipTransferRequestedIterator, error) + + WatchOwnershipTransferRequested(opts *bind.WatchOpts, sink chan<- *LinkTokenOwnershipTransferRequested, from []common.Address, to []common.Address) (event.Subscription, error) + + ParseOwnershipTransferRequested(log types.Log) (*LinkTokenOwnershipTransferRequested, error) + + FilterOwnershipTransferred(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LinkTokenOwnershipTransferredIterator, error) + + WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *LinkTokenOwnershipTransferred, from []common.Address, to []common.Address) (event.Subscription, error) + + ParseOwnershipTransferred(log types.Log) (*LinkTokenOwnershipTransferred, error) + + FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LinkTokenTransferIterator, error) + + WatchTransfer(opts *bind.WatchOpts, sink chan<- *LinkTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) + + ParseTransfer(log types.Log) (*LinkTokenTransfer, error) + + FilterTransfer0(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LinkTokenTransfer0Iterator, error) + + WatchTransfer0(opts *bind.WatchOpts, sink chan<- *LinkTokenTransfer0, from []common.Address, to []common.Address) (event.Subscription, error) + + ParseTransfer0(log types.Log) (*LinkTokenTransfer0, error) + + Address() common.Address +} diff --git a/tools/operations-gen/testdata/evm/gobindings/v1_0_0/many_chain_multisig/many_chain_multisig.go b/tools/operations-gen/testdata/evm/gobindings/v1_0_0/many_chain_multisig/many_chain_multisig.go new file mode 100644 index 000000000..314ca109b --- /dev/null +++ b/tools/operations-gen/testdata/evm/gobindings/v1_0_0/many_chain_multisig/many_chain_multisig.go @@ -0,0 +1,1238 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package many_chain_multi_sig + +import ( + "errors" + "fmt" + "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" +) + +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +type ManyChainMultiSigConfig struct { + Signers []ManyChainMultiSigSigner + GroupQuorums [32]uint8 + GroupParents [32]uint8 +} + +type ManyChainMultiSigOp struct { + ChainId *big.Int + MultiSig common.Address + Nonce *big.Int + To common.Address + Value *big.Int + Data []byte +} + +type ManyChainMultiSigRootMetadata struct { + ChainId *big.Int + MultiSig common.Address + PreOpCount *big.Int + PostOpCount *big.Int + OverridePreviousRoot bool +} + +type ManyChainMultiSigSignature struct { + V uint8 + R [32]byte + S [32]byte +} + +type ManyChainMultiSigSigner struct { + Addr common.Address + Index uint8 + Group uint8 +} + +var ManyChainMultiSigMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"receive\",\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"MAX_NUM_SIGNERS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"NUM_GROUPS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"acceptOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"execute\",\"inputs\":[{\"name\":\"op\",\"type\":\"tuple\",\"internalType\":\"structManyChainMultiSig.Op\",\"components\":[{\"name\":\"chainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"multiSig\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint40\",\"internalType\":\"uint40\"},{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"proof\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"getConfig\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structManyChainMultiSig.Config\",\"components\":[{\"name\":\"signers\",\"type\":\"tuple[]\",\"internalType\":\"structManyChainMultiSig.Signer[]\",\"components\":[{\"name\":\"addr\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"group\",\"type\":\"uint8\",\"internalType\":\"uint8\"}]},{\"name\":\"groupQuorums\",\"type\":\"uint8[32]\",\"internalType\":\"uint8[32]\"},{\"name\":\"groupParents\",\"type\":\"uint8[32]\",\"internalType\":\"uint8[32]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOpCount\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint40\",\"internalType\":\"uint40\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"root\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"validUntil\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRootMetadata\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structManyChainMultiSig.RootMetadata\",\"components\":[{\"name\":\"chainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"multiSig\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"preOpCount\",\"type\":\"uint40\",\"internalType\":\"uint40\"},{\"name\":\"postOpCount\",\"type\":\"uint40\",\"internalType\":\"uint40\"},{\"name\":\"overridePreviousRoot\",\"type\":\"bool\",\"internalType\":\"bool\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingOwner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setConfig\",\"inputs\":[{\"name\":\"signerAddresses\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"signerGroups\",\"type\":\"uint8[]\",\"internalType\":\"uint8[]\"},{\"name\":\"groupQuorums\",\"type\":\"uint8[32]\",\"internalType\":\"uint8[32]\"},{\"name\":\"groupParents\",\"type\":\"uint8[32]\",\"internalType\":\"uint8[32]\"},{\"name\":\"clearRoot\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setRoot\",\"inputs\":[{\"name\":\"root\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"validUntil\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"metadata\",\"type\":\"tuple\",\"internalType\":\"structManyChainMultiSig.RootMetadata\",\"components\":[{\"name\":\"chainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"multiSig\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"preOpCount\",\"type\":\"uint40\",\"internalType\":\"uint40\"},{\"name\":\"postOpCount\",\"type\":\"uint40\",\"internalType\":\"uint40\"},{\"name\":\"overridePreviousRoot\",\"type\":\"bool\",\"internalType\":\"bool\"}]},{\"name\":\"metadataProof\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"},{\"name\":\"signatures\",\"type\":\"tuple[]\",\"internalType\":\"structManyChainMultiSig.Signature[]\",\"components\":[{\"name\":\"v\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"r\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"s\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"ConfigSet\",\"inputs\":[{\"name\":\"config\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structManyChainMultiSig.Config\",\"components\":[{\"name\":\"signers\",\"type\":\"tuple[]\",\"internalType\":\"structManyChainMultiSig.Signer[]\",\"components\":[{\"name\":\"addr\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"group\",\"type\":\"uint8\",\"internalType\":\"uint8\"}]},{\"name\":\"groupQuorums\",\"type\":\"uint8[32]\",\"internalType\":\"uint8[32]\"},{\"name\":\"groupParents\",\"type\":\"uint8[32]\",\"internalType\":\"uint8[32]\"}]},{\"name\":\"isRootCleared\",\"type\":\"bool\",\"indexed\":false,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewRoot\",\"inputs\":[{\"name\":\"root\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"validUntil\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"metadata\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structManyChainMultiSig.RootMetadata\",\"components\":[{\"name\":\"chainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"multiSig\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"preOpCount\",\"type\":\"uint40\",\"internalType\":\"uint40\"},{\"name\":\"postOpCount\",\"type\":\"uint40\",\"internalType\":\"uint40\"},{\"name\":\"overridePreviousRoot\",\"type\":\"bool\",\"internalType\":\"bool\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OpExecuted\",\"inputs\":[{\"name\":\"nonce\",\"type\":\"uint40\",\"indexed\":true,\"internalType\":\"uint40\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"data\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferStarted\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CallReverted\",\"inputs\":[{\"name\":\"error\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"type\":\"error\",\"name\":\"GroupTreeNotWellFormed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientSigners\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSigner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MissingConfig\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OutOfBoundsGroup\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OutOfBoundsGroupQuorum\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OutOfBoundsNumOfSigners\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"PendingOps\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"PostOpCountReached\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProofCannotBeVerified\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"RootExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignedHashAlreadySeen\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignerGroupsLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignerInDisabledGroup\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignersAddressesMustBeStrictlyIncreasing\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ValidUntilHasAlreadyPassed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WrongChainId\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WrongMultiSig\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WrongNonce\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WrongPostOpCount\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WrongPreOpCount\",\"inputs\":[]}]", + Bin: "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", +} + +var ManyChainMultiSigABI = ManyChainMultiSigMetaData.ABI + +var ManyChainMultiSigBin = ManyChainMultiSigMetaData.Bin + +func DeployManyChainMultiSig(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ManyChainMultiSig, error) { + parsed, err := ManyChainMultiSigMetaData.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(ManyChainMultiSigBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ManyChainMultiSig{address: address, abi: *parsed, ManyChainMultiSigCaller: ManyChainMultiSigCaller{contract: contract}, ManyChainMultiSigTransactor: ManyChainMultiSigTransactor{contract: contract}, ManyChainMultiSigFilterer: ManyChainMultiSigFilterer{contract: contract}}, nil +} + +type ManyChainMultiSig struct { + address common.Address + abi abi.ABI + ManyChainMultiSigCaller + ManyChainMultiSigTransactor + ManyChainMultiSigFilterer +} + +type ManyChainMultiSigCaller struct { + contract *bind.BoundContract +} + +type ManyChainMultiSigTransactor struct { + contract *bind.BoundContract +} + +type ManyChainMultiSigFilterer struct { + contract *bind.BoundContract +} + +type ManyChainMultiSigSession struct { + Contract *ManyChainMultiSig + CallOpts bind.CallOpts + TransactOpts bind.TransactOpts +} + +type ManyChainMultiSigCallerSession struct { + Contract *ManyChainMultiSigCaller + CallOpts bind.CallOpts +} + +type ManyChainMultiSigTransactorSession struct { + Contract *ManyChainMultiSigTransactor + TransactOpts bind.TransactOpts +} + +type ManyChainMultiSigRaw struct { + Contract *ManyChainMultiSig +} + +type ManyChainMultiSigCallerRaw struct { + Contract *ManyChainMultiSigCaller +} + +type ManyChainMultiSigTransactorRaw struct { + Contract *ManyChainMultiSigTransactor +} + +func NewManyChainMultiSig(address common.Address, backend bind.ContractBackend) (*ManyChainMultiSig, error) { + abi, err := abi.JSON(strings.NewReader(ManyChainMultiSigABI)) + if err != nil { + return nil, err + } + contract, err := bindManyChainMultiSig(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ManyChainMultiSig{address: address, abi: abi, ManyChainMultiSigCaller: ManyChainMultiSigCaller{contract: contract}, ManyChainMultiSigTransactor: ManyChainMultiSigTransactor{contract: contract}, ManyChainMultiSigFilterer: ManyChainMultiSigFilterer{contract: contract}}, nil +} + +func NewManyChainMultiSigCaller(address common.Address, caller bind.ContractCaller) (*ManyChainMultiSigCaller, error) { + contract, err := bindManyChainMultiSig(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ManyChainMultiSigCaller{contract: contract}, nil +} + +func NewManyChainMultiSigTransactor(address common.Address, transactor bind.ContractTransactor) (*ManyChainMultiSigTransactor, error) { + contract, err := bindManyChainMultiSig(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ManyChainMultiSigTransactor{contract: contract}, nil +} + +func NewManyChainMultiSigFilterer(address common.Address, filterer bind.ContractFilterer) (*ManyChainMultiSigFilterer, error) { + contract, err := bindManyChainMultiSig(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ManyChainMultiSigFilterer{contract: contract}, nil +} + +func bindManyChainMultiSig(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ManyChainMultiSigMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +func (_ManyChainMultiSig *ManyChainMultiSigRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ManyChainMultiSig.Contract.ManyChainMultiSigCaller.contract.Call(opts, result, method, params...) +} + +func (_ManyChainMultiSig *ManyChainMultiSigRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.ManyChainMultiSigTransactor.contract.Transfer(opts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.ManyChainMultiSigTransactor.contract.Transact(opts, method, params...) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ManyChainMultiSig.Contract.contract.Call(opts, result, method, params...) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.contract.Transfer(opts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.contract.Transact(opts, method, params...) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCaller) MAXNUMSIGNERS(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _ManyChainMultiSig.contract.Call(opts, &out, "MAX_NUM_SIGNERS") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) MAXNUMSIGNERS() (uint8, error) { + return _ManyChainMultiSig.Contract.MAXNUMSIGNERS(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCallerSession) MAXNUMSIGNERS() (uint8, error) { + return _ManyChainMultiSig.Contract.MAXNUMSIGNERS(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCaller) NUMGROUPS(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _ManyChainMultiSig.contract.Call(opts, &out, "NUM_GROUPS") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) NUMGROUPS() (uint8, error) { + return _ManyChainMultiSig.Contract.NUMGROUPS(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCallerSession) NUMGROUPS() (uint8, error) { + return _ManyChainMultiSig.Contract.NUMGROUPS(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCaller) GetConfig(opts *bind.CallOpts) (ManyChainMultiSigConfig, error) { + var out []interface{} + err := _ManyChainMultiSig.contract.Call(opts, &out, "getConfig") + + if err != nil { + return *new(ManyChainMultiSigConfig), err + } + + out0 := *abi.ConvertType(out[0], new(ManyChainMultiSigConfig)).(*ManyChainMultiSigConfig) + + return out0, err + +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) GetConfig() (ManyChainMultiSigConfig, error) { + return _ManyChainMultiSig.Contract.GetConfig(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCallerSession) GetConfig() (ManyChainMultiSigConfig, error) { + return _ManyChainMultiSig.Contract.GetConfig(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCaller) GetOpCount(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _ManyChainMultiSig.contract.Call(opts, &out, "getOpCount") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) GetOpCount() (*big.Int, error) { + return _ManyChainMultiSig.Contract.GetOpCount(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCallerSession) GetOpCount() (*big.Int, error) { + return _ManyChainMultiSig.Contract.GetOpCount(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCaller) GetRoot(opts *bind.CallOpts) (GetRoot, + + error) { + var out []interface{} + err := _ManyChainMultiSig.contract.Call(opts, &out, "getRoot") + + outstruct := new(GetRoot) + if err != nil { + return *outstruct, err + } + + outstruct.Root = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + outstruct.ValidUntil = *abi.ConvertType(out[1], new(uint32)).(*uint32) + + return *outstruct, err + +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) GetRoot() (GetRoot, + + error) { + return _ManyChainMultiSig.Contract.GetRoot(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCallerSession) GetRoot() (GetRoot, + + error) { + return _ManyChainMultiSig.Contract.GetRoot(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCaller) GetRootMetadata(opts *bind.CallOpts) (ManyChainMultiSigRootMetadata, error) { + var out []interface{} + err := _ManyChainMultiSig.contract.Call(opts, &out, "getRootMetadata") + + if err != nil { + return *new(ManyChainMultiSigRootMetadata), err + } + + out0 := *abi.ConvertType(out[0], new(ManyChainMultiSigRootMetadata)).(*ManyChainMultiSigRootMetadata) + + return out0, err + +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) GetRootMetadata() (ManyChainMultiSigRootMetadata, error) { + return _ManyChainMultiSig.Contract.GetRootMetadata(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCallerSession) GetRootMetadata() (ManyChainMultiSigRootMetadata, error) { + return _ManyChainMultiSig.Contract.GetRootMetadata(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ManyChainMultiSig.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 + +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) Owner() (common.Address, error) { + return _ManyChainMultiSig.Contract.Owner(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCallerSession) Owner() (common.Address, error) { + return _ManyChainMultiSig.Contract.Owner(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCaller) PendingOwner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ManyChainMultiSig.contract.Call(opts, &out, "pendingOwner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) PendingOwner() (common.Address, error) { + return _ManyChainMultiSig.Contract.PendingOwner(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigCallerSession) PendingOwner() (common.Address, error) { + return _ManyChainMultiSig.Contract.PendingOwner(&_ManyChainMultiSig.CallOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ManyChainMultiSig.contract.Transact(opts, "acceptOwnership") +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) AcceptOwnership() (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.AcceptOwnership(&_ManyChainMultiSig.TransactOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactorSession) AcceptOwnership() (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.AcceptOwnership(&_ManyChainMultiSig.TransactOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactor) Execute(opts *bind.TransactOpts, op ManyChainMultiSigOp, proof [][32]byte) (*types.Transaction, error) { + return _ManyChainMultiSig.contract.Transact(opts, "execute", op, proof) +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) Execute(op ManyChainMultiSigOp, proof [][32]byte) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.Execute(&_ManyChainMultiSig.TransactOpts, op, proof) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactorSession) Execute(op ManyChainMultiSigOp, proof [][32]byte) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.Execute(&_ManyChainMultiSig.TransactOpts, op, proof) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ManyChainMultiSig.contract.Transact(opts, "renounceOwnership") +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) RenounceOwnership() (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.RenounceOwnership(&_ManyChainMultiSig.TransactOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.RenounceOwnership(&_ManyChainMultiSig.TransactOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactor) SetConfig(opts *bind.TransactOpts, signerAddresses []common.Address, signerGroups []uint8, groupQuorums [32]uint8, groupParents [32]uint8, clearRoot bool) (*types.Transaction, error) { + return _ManyChainMultiSig.contract.Transact(opts, "setConfig", signerAddresses, signerGroups, groupQuorums, groupParents, clearRoot) +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) SetConfig(signerAddresses []common.Address, signerGroups []uint8, groupQuorums [32]uint8, groupParents [32]uint8, clearRoot bool) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.SetConfig(&_ManyChainMultiSig.TransactOpts, signerAddresses, signerGroups, groupQuorums, groupParents, clearRoot) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactorSession) SetConfig(signerAddresses []common.Address, signerGroups []uint8, groupQuorums [32]uint8, groupParents [32]uint8, clearRoot bool) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.SetConfig(&_ManyChainMultiSig.TransactOpts, signerAddresses, signerGroups, groupQuorums, groupParents, clearRoot) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactor) SetRoot(opts *bind.TransactOpts, root [32]byte, validUntil uint32, metadata ManyChainMultiSigRootMetadata, metadataProof [][32]byte, signatures []ManyChainMultiSigSignature) (*types.Transaction, error) { + return _ManyChainMultiSig.contract.Transact(opts, "setRoot", root, validUntil, metadata, metadataProof, signatures) +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) SetRoot(root [32]byte, validUntil uint32, metadata ManyChainMultiSigRootMetadata, metadataProof [][32]byte, signatures []ManyChainMultiSigSignature) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.SetRoot(&_ManyChainMultiSig.TransactOpts, root, validUntil, metadata, metadataProof, signatures) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactorSession) SetRoot(root [32]byte, validUntil uint32, metadata ManyChainMultiSigRootMetadata, metadataProof [][32]byte, signatures []ManyChainMultiSigSignature) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.SetRoot(&_ManyChainMultiSig.TransactOpts, root, validUntil, metadata, metadataProof, signatures) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _ManyChainMultiSig.contract.Transact(opts, "transferOwnership", newOwner) +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.TransferOwnership(&_ManyChainMultiSig.TransactOpts, newOwner) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.TransferOwnership(&_ManyChainMultiSig.TransactOpts, newOwner) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ManyChainMultiSig.contract.RawTransact(opts, nil) +} + +func (_ManyChainMultiSig *ManyChainMultiSigSession) Receive() (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.Receive(&_ManyChainMultiSig.TransactOpts) +} + +func (_ManyChainMultiSig *ManyChainMultiSigTransactorSession) Receive() (*types.Transaction, error) { + return _ManyChainMultiSig.Contract.Receive(&_ManyChainMultiSig.TransactOpts) +} + +type ManyChainMultiSigConfigSetIterator struct { + Event *ManyChainMultiSigConfigSet + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *ManyChainMultiSigConfigSetIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigConfigSet) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigConfigSet) + 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() + } +} + +func (it *ManyChainMultiSigConfigSetIterator) Error() error { + return it.fail +} + +func (it *ManyChainMultiSigConfigSetIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type ManyChainMultiSigConfigSet struct { + Config ManyChainMultiSigConfig + IsRootCleared bool + Raw types.Log +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) FilterConfigSet(opts *bind.FilterOpts) (*ManyChainMultiSigConfigSetIterator, error) { + + logs, sub, err := _ManyChainMultiSig.contract.FilterLogs(opts, "ConfigSet") + if err != nil { + return nil, err + } + return &ManyChainMultiSigConfigSetIterator{contract: _ManyChainMultiSig.contract, event: "ConfigSet", logs: logs, sub: sub}, nil +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) WatchConfigSet(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigConfigSet) (event.Subscription, error) { + + logs, sub, err := _ManyChainMultiSig.contract.WatchLogs(opts, "ConfigSet") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(ManyChainMultiSigConfigSet) + if err := _ManyChainMultiSig.contract.UnpackLog(event, "ConfigSet", 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 +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) ParseConfigSet(log types.Log) (*ManyChainMultiSigConfigSet, error) { + event := new(ManyChainMultiSigConfigSet) + if err := _ManyChainMultiSig.contract.UnpackLog(event, "ConfigSet", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type ManyChainMultiSigNewRootIterator struct { + Event *ManyChainMultiSigNewRoot + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *ManyChainMultiSigNewRootIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigNewRoot) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigNewRoot) + 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() + } +} + +func (it *ManyChainMultiSigNewRootIterator) Error() error { + return it.fail +} + +func (it *ManyChainMultiSigNewRootIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type ManyChainMultiSigNewRoot struct { + Root [32]byte + ValidUntil uint32 + Metadata ManyChainMultiSigRootMetadata + Raw types.Log +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) FilterNewRoot(opts *bind.FilterOpts, root [][32]byte) (*ManyChainMultiSigNewRootIterator, error) { + + var rootRule []interface{} + for _, rootItem := range root { + rootRule = append(rootRule, rootItem) + } + + logs, sub, err := _ManyChainMultiSig.contract.FilterLogs(opts, "NewRoot", rootRule) + if err != nil { + return nil, err + } + return &ManyChainMultiSigNewRootIterator{contract: _ManyChainMultiSig.contract, event: "NewRoot", logs: logs, sub: sub}, nil +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) WatchNewRoot(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigNewRoot, root [][32]byte) (event.Subscription, error) { + + var rootRule []interface{} + for _, rootItem := range root { + rootRule = append(rootRule, rootItem) + } + + logs, sub, err := _ManyChainMultiSig.contract.WatchLogs(opts, "NewRoot", rootRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(ManyChainMultiSigNewRoot) + if err := _ManyChainMultiSig.contract.UnpackLog(event, "NewRoot", 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 +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) ParseNewRoot(log types.Log) (*ManyChainMultiSigNewRoot, error) { + event := new(ManyChainMultiSigNewRoot) + if err := _ManyChainMultiSig.contract.UnpackLog(event, "NewRoot", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type ManyChainMultiSigOpExecutedIterator struct { + Event *ManyChainMultiSigOpExecuted + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *ManyChainMultiSigOpExecutedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigOpExecuted) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigOpExecuted) + 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() + } +} + +func (it *ManyChainMultiSigOpExecutedIterator) Error() error { + return it.fail +} + +func (it *ManyChainMultiSigOpExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type ManyChainMultiSigOpExecuted struct { + Nonce *big.Int + To common.Address + Data []byte + Value *big.Int + Raw types.Log +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) FilterOpExecuted(opts *bind.FilterOpts, nonce []*big.Int) (*ManyChainMultiSigOpExecutedIterator, error) { + + var nonceRule []interface{} + for _, nonceItem := range nonce { + nonceRule = append(nonceRule, nonceItem) + } + + logs, sub, err := _ManyChainMultiSig.contract.FilterLogs(opts, "OpExecuted", nonceRule) + if err != nil { + return nil, err + } + return &ManyChainMultiSigOpExecutedIterator{contract: _ManyChainMultiSig.contract, event: "OpExecuted", logs: logs, sub: sub}, nil +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) WatchOpExecuted(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigOpExecuted, nonce []*big.Int) (event.Subscription, error) { + + var nonceRule []interface{} + for _, nonceItem := range nonce { + nonceRule = append(nonceRule, nonceItem) + } + + logs, sub, err := _ManyChainMultiSig.contract.WatchLogs(opts, "OpExecuted", nonceRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(ManyChainMultiSigOpExecuted) + if err := _ManyChainMultiSig.contract.UnpackLog(event, "OpExecuted", 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 +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) ParseOpExecuted(log types.Log) (*ManyChainMultiSigOpExecuted, error) { + event := new(ManyChainMultiSigOpExecuted) + if err := _ManyChainMultiSig.contract.UnpackLog(event, "OpExecuted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type ManyChainMultiSigOwnershipTransferStartedIterator struct { + Event *ManyChainMultiSigOwnershipTransferStarted + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *ManyChainMultiSigOwnershipTransferStartedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigOwnershipTransferStarted) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigOwnershipTransferStarted) + 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() + } +} + +func (it *ManyChainMultiSigOwnershipTransferStartedIterator) Error() error { + return it.fail +} + +func (it *ManyChainMultiSigOwnershipTransferStartedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type ManyChainMultiSigOwnershipTransferStarted struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) FilterOwnershipTransferStarted(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ManyChainMultiSigOwnershipTransferStartedIterator, 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 := _ManyChainMultiSig.contract.FilterLogs(opts, "OwnershipTransferStarted", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &ManyChainMultiSigOwnershipTransferStartedIterator{contract: _ManyChainMultiSig.contract, event: "OwnershipTransferStarted", logs: logs, sub: sub}, nil +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) WatchOwnershipTransferStarted(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigOwnershipTransferStarted, 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 := _ManyChainMultiSig.contract.WatchLogs(opts, "OwnershipTransferStarted", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(ManyChainMultiSigOwnershipTransferStarted) + if err := _ManyChainMultiSig.contract.UnpackLog(event, "OwnershipTransferStarted", 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 +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) ParseOwnershipTransferStarted(log types.Log) (*ManyChainMultiSigOwnershipTransferStarted, error) { + event := new(ManyChainMultiSigOwnershipTransferStarted) + if err := _ManyChainMultiSig.contract.UnpackLog(event, "OwnershipTransferStarted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type ManyChainMultiSigOwnershipTransferredIterator struct { + Event *ManyChainMultiSigOwnershipTransferred + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *ManyChainMultiSigOwnershipTransferredIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigOwnershipTransferred) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(ManyChainMultiSigOwnershipTransferred) + 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() + } +} + +func (it *ManyChainMultiSigOwnershipTransferredIterator) Error() error { + return it.fail +} + +func (it *ManyChainMultiSigOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type ManyChainMultiSigOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ManyChainMultiSigOwnershipTransferredIterator, 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 := _ManyChainMultiSig.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &ManyChainMultiSigOwnershipTransferredIterator{contract: _ManyChainMultiSig.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigOwnershipTransferred, 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 := _ManyChainMultiSig.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: + + event := new(ManyChainMultiSigOwnershipTransferred) + if err := _ManyChainMultiSig.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 +} + +func (_ManyChainMultiSig *ManyChainMultiSigFilterer) ParseOwnershipTransferred(log types.Log) (*ManyChainMultiSigOwnershipTransferred, error) { + event := new(ManyChainMultiSigOwnershipTransferred) + if err := _ManyChainMultiSig.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type GetRoot struct { + Root [32]byte + ValidUntil uint32 +} + +func (_ManyChainMultiSig *ManyChainMultiSig) ParseLog(log types.Log) (AbigenLog, error) { + switch log.Topics[0] { + case _ManyChainMultiSig.abi.Events["ConfigSet"].ID: + return _ManyChainMultiSig.ParseConfigSet(log) + case _ManyChainMultiSig.abi.Events["NewRoot"].ID: + return _ManyChainMultiSig.ParseNewRoot(log) + case _ManyChainMultiSig.abi.Events["OpExecuted"].ID: + return _ManyChainMultiSig.ParseOpExecuted(log) + case _ManyChainMultiSig.abi.Events["OwnershipTransferStarted"].ID: + return _ManyChainMultiSig.ParseOwnershipTransferStarted(log) + case _ManyChainMultiSig.abi.Events["OwnershipTransferred"].ID: + return _ManyChainMultiSig.ParseOwnershipTransferred(log) + + default: + return nil, fmt.Errorf("abigen wrapper received unknown log topic: %v", log.Topics[0]) + } +} + +func (ManyChainMultiSigConfigSet) Topic() common.Hash { + return common.HexToHash("0x0a4974ad206b9c736f9ab2feac1c9b1d043fe4ef377c70ae45659f2ef089f03e") +} + +func (ManyChainMultiSigNewRoot) Topic() common.Hash { + return common.HexToHash("0x7ea643ae44677f24e0d6f40168893712daaf729b0a38fe7702d21cb544c84101") +} + +func (ManyChainMultiSigOpExecuted) Topic() common.Hash { + return common.HexToHash("0x87d58fdd48be753fb9ef4ec8a5895086c401506da8b4d752abc90602c3e62d1d") +} + +func (ManyChainMultiSigOwnershipTransferStarted) Topic() common.Hash { + return common.HexToHash("0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700") +} + +func (ManyChainMultiSigOwnershipTransferred) Topic() common.Hash { + return common.HexToHash("0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0") +} + +func (_ManyChainMultiSig *ManyChainMultiSig) Address() common.Address { + return _ManyChainMultiSig.address +} + +type ManyChainMultiSigInterface interface { + MAXNUMSIGNERS(opts *bind.CallOpts) (uint8, error) + + NUMGROUPS(opts *bind.CallOpts) (uint8, error) + + GetConfig(opts *bind.CallOpts) (ManyChainMultiSigConfig, error) + + GetOpCount(opts *bind.CallOpts) (*big.Int, error) + + GetRoot(opts *bind.CallOpts) (GetRoot, + + error) + + GetRootMetadata(opts *bind.CallOpts) (ManyChainMultiSigRootMetadata, error) + + Owner(opts *bind.CallOpts) (common.Address, error) + + PendingOwner(opts *bind.CallOpts) (common.Address, error) + + AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) + + Execute(opts *bind.TransactOpts, op ManyChainMultiSigOp, proof [][32]byte) (*types.Transaction, error) + + RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) + + SetConfig(opts *bind.TransactOpts, signerAddresses []common.Address, signerGroups []uint8, groupQuorums [32]uint8, groupParents [32]uint8, clearRoot bool) (*types.Transaction, error) + + SetRoot(opts *bind.TransactOpts, root [32]byte, validUntil uint32, metadata ManyChainMultiSigRootMetadata, metadataProof [][32]byte, signatures []ManyChainMultiSigSignature) (*types.Transaction, error) + + TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) + + Receive(opts *bind.TransactOpts) (*types.Transaction, error) + + FilterConfigSet(opts *bind.FilterOpts) (*ManyChainMultiSigConfigSetIterator, error) + + WatchConfigSet(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigConfigSet) (event.Subscription, error) + + ParseConfigSet(log types.Log) (*ManyChainMultiSigConfigSet, error) + + FilterNewRoot(opts *bind.FilterOpts, root [][32]byte) (*ManyChainMultiSigNewRootIterator, error) + + WatchNewRoot(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigNewRoot, root [][32]byte) (event.Subscription, error) + + ParseNewRoot(log types.Log) (*ManyChainMultiSigNewRoot, error) + + FilterOpExecuted(opts *bind.FilterOpts, nonce []*big.Int) (*ManyChainMultiSigOpExecutedIterator, error) + + WatchOpExecuted(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigOpExecuted, nonce []*big.Int) (event.Subscription, error) + + ParseOpExecuted(log types.Log) (*ManyChainMultiSigOpExecuted, error) + + FilterOwnershipTransferStarted(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ManyChainMultiSigOwnershipTransferStartedIterator, error) + + WatchOwnershipTransferStarted(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigOwnershipTransferStarted, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) + + ParseOwnershipTransferStarted(log types.Log) (*ManyChainMultiSigOwnershipTransferStarted, error) + + FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ManyChainMultiSigOwnershipTransferredIterator, error) + + WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ManyChainMultiSigOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) + + ParseOwnershipTransferred(log types.Log) (*ManyChainMultiSigOwnershipTransferred, error) + + ParseLog(log types.Log) (AbigenLog, error) + + Address() common.Address +} diff --git a/tools/operations-gen/testdata/evm/gobindings/v1_0_0/rbac_timelock/rbac_timelock.go b/tools/operations-gen/testdata/evm/gobindings/v1_0_0/rbac_timelock/rbac_timelock.go new file mode 100644 index 000000000..887c5731f --- /dev/null +++ b/tools/operations-gen/testdata/evm/gobindings/v1_0_0/rbac_timelock/rbac_timelock.go @@ -0,0 +1,2336 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package rbac_timelock + +import ( + "errors" + "fmt" + "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" +) + +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +type RBACTimelockCall struct { + Target common.Address + Value *big.Int + Data []byte +} + +var RBACTimelockMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"minDelay\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"admin\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"proposers\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"executors\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"cancellers\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"bypassers\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"receive\",\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"ADMIN_ROLE\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"BYPASSER_ROLE\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"CANCELLER_ROLE\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DEFAULT_ADMIN_ROLE\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"EXECUTOR_ROLE\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"PROPOSER_ROLE\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blockFunctionSelector\",\"inputs\":[{\"name\":\"selector\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"bypasserExecuteBatch\",\"inputs\":[{\"name\":\"calls\",\"type\":\"tuple[]\",\"internalType\":\"structRBACTimelock.Call[]\",\"components\":[{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"cancel\",\"inputs\":[{\"name\":\"id\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"executeBatch\",\"inputs\":[{\"name\":\"calls\",\"type\":\"tuple[]\",\"internalType\":\"structRBACTimelock.Call[]\",\"components\":[{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"predecessor\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"getBlockedFunctionSelectorAt\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getBlockedFunctionSelectorCount\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMinDelay\",\"inputs\":[],\"outputs\":[{\"name\":\"duration\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRoleAdmin\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRoleMember\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRoleMemberCount\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTimestamp\",\"inputs\":[{\"name\":\"id\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"timestamp\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"grantRole\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"hasRole\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"hashOperationBatch\",\"inputs\":[{\"name\":\"calls\",\"type\":\"tuple[]\",\"internalType\":\"structRBACTimelock.Call[]\",\"components\":[{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"predecessor\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"hash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"isOperation\",\"inputs\":[{\"name\":\"id\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"registered\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperationDone\",\"inputs\":[{\"name\":\"id\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"done\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperationPending\",\"inputs\":[{\"name\":\"id\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"pending\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperationReady\",\"inputs\":[{\"name\":\"id\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"ready\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"onERC1155BatchReceived\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"onERC1155Received\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"onERC721Received\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceRole\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"revokeRole\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"scheduleBatch\",\"inputs\":[{\"name\":\"calls\",\"type\":\"tuple[]\",\"internalType\":\"structRBACTimelock.Call[]\",\"components\":[{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"predecessor\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"delay\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"supportsInterface\",\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unblockFunctionSelector\",\"inputs\":[{\"name\":\"selector\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateDelay\",\"inputs\":[{\"name\":\"newDelay\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BypasserCallExecuted\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"target\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"CallExecuted\",\"inputs\":[{\"name\":\"id\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"index\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"target\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"CallScheduled\",\"inputs\":[{\"name\":\"id\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"index\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"target\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"},{\"name\":\"predecessor\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"delay\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Cancelled\",\"inputs\":[{\"name\":\"id\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FunctionSelectorBlocked\",\"inputs\":[{\"name\":\"selector\",\"type\":\"bytes4\",\"indexed\":true,\"internalType\":\"bytes4\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FunctionSelectorUnblocked\",\"inputs\":[{\"name\":\"selector\",\"type\":\"bytes4\",\"indexed\":true,\"internalType\":\"bytes4\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MinDelayChange\",\"inputs\":[{\"name\":\"oldDuration\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"newDuration\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"RoleAdminChanged\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"previousAdminRole\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"newAdminRole\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"RoleGranted\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"sender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"RoleRevoked\",\"inputs\":[{\"name\":\"role\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"sender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false}]", + Bin: "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", +} + +var RBACTimelockABI = RBACTimelockMetaData.ABI + +var RBACTimelockBin = RBACTimelockMetaData.Bin + +func DeployRBACTimelock(auth *bind.TransactOpts, backend bind.ContractBackend, minDelay *big.Int, admin common.Address, proposers []common.Address, executors []common.Address, cancellers []common.Address, bypassers []common.Address) (common.Address, *types.Transaction, *RBACTimelock, error) { + parsed, err := RBACTimelockMetaData.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(RBACTimelockBin), backend, minDelay, admin, proposers, executors, cancellers, bypassers) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &RBACTimelock{address: address, abi: *parsed, RBACTimelockCaller: RBACTimelockCaller{contract: contract}, RBACTimelockTransactor: RBACTimelockTransactor{contract: contract}, RBACTimelockFilterer: RBACTimelockFilterer{contract: contract}}, nil +} + +type RBACTimelock struct { + address common.Address + abi abi.ABI + RBACTimelockCaller + RBACTimelockTransactor + RBACTimelockFilterer +} + +type RBACTimelockCaller struct { + contract *bind.BoundContract +} + +type RBACTimelockTransactor struct { + contract *bind.BoundContract +} + +type RBACTimelockFilterer struct { + contract *bind.BoundContract +} + +type RBACTimelockSession struct { + Contract *RBACTimelock + CallOpts bind.CallOpts + TransactOpts bind.TransactOpts +} + +type RBACTimelockCallerSession struct { + Contract *RBACTimelockCaller + CallOpts bind.CallOpts +} + +type RBACTimelockTransactorSession struct { + Contract *RBACTimelockTransactor + TransactOpts bind.TransactOpts +} + +type RBACTimelockRaw struct { + Contract *RBACTimelock +} + +type RBACTimelockCallerRaw struct { + Contract *RBACTimelockCaller +} + +type RBACTimelockTransactorRaw struct { + Contract *RBACTimelockTransactor +} + +func NewRBACTimelock(address common.Address, backend bind.ContractBackend) (*RBACTimelock, error) { + abi, err := abi.JSON(strings.NewReader(RBACTimelockABI)) + if err != nil { + return nil, err + } + contract, err := bindRBACTimelock(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &RBACTimelock{address: address, abi: abi, RBACTimelockCaller: RBACTimelockCaller{contract: contract}, RBACTimelockTransactor: RBACTimelockTransactor{contract: contract}, RBACTimelockFilterer: RBACTimelockFilterer{contract: contract}}, nil +} + +func NewRBACTimelockCaller(address common.Address, caller bind.ContractCaller) (*RBACTimelockCaller, error) { + contract, err := bindRBACTimelock(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &RBACTimelockCaller{contract: contract}, nil +} + +func NewRBACTimelockTransactor(address common.Address, transactor bind.ContractTransactor) (*RBACTimelockTransactor, error) { + contract, err := bindRBACTimelock(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &RBACTimelockTransactor{contract: contract}, nil +} + +func NewRBACTimelockFilterer(address common.Address, filterer bind.ContractFilterer) (*RBACTimelockFilterer, error) { + contract, err := bindRBACTimelock(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &RBACTimelockFilterer{contract: contract}, nil +} + +func bindRBACTimelock(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := RBACTimelockMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +func (_RBACTimelock *RBACTimelockRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _RBACTimelock.Contract.RBACTimelockCaller.contract.Call(opts, result, method, params...) +} + +func (_RBACTimelock *RBACTimelockRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _RBACTimelock.Contract.RBACTimelockTransactor.contract.Transfer(opts) +} + +func (_RBACTimelock *RBACTimelockRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _RBACTimelock.Contract.RBACTimelockTransactor.contract.Transact(opts, method, params...) +} + +func (_RBACTimelock *RBACTimelockCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _RBACTimelock.Contract.contract.Call(opts, result, method, params...) +} + +func (_RBACTimelock *RBACTimelockTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _RBACTimelock.Contract.contract.Transfer(opts) +} + +func (_RBACTimelock *RBACTimelockTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _RBACTimelock.Contract.contract.Transact(opts, method, params...) +} + +func (_RBACTimelock *RBACTimelockCaller) ADMINROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "ADMIN_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) ADMINROLE() ([32]byte, error) { + return _RBACTimelock.Contract.ADMINROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCallerSession) ADMINROLE() ([32]byte, error) { + return _RBACTimelock.Contract.ADMINROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCaller) BYPASSERROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "BYPASSER_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) BYPASSERROLE() ([32]byte, error) { + return _RBACTimelock.Contract.BYPASSERROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCallerSession) BYPASSERROLE() ([32]byte, error) { + return _RBACTimelock.Contract.BYPASSERROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCaller) CANCELLERROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "CANCELLER_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) CANCELLERROLE() ([32]byte, error) { + return _RBACTimelock.Contract.CANCELLERROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCallerSession) CANCELLERROLE() ([32]byte, error) { + return _RBACTimelock.Contract.CANCELLERROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCaller) DEFAULTADMINROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "DEFAULT_ADMIN_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) DEFAULTADMINROLE() ([32]byte, error) { + return _RBACTimelock.Contract.DEFAULTADMINROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCallerSession) DEFAULTADMINROLE() ([32]byte, error) { + return _RBACTimelock.Contract.DEFAULTADMINROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCaller) EXECUTORROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "EXECUTOR_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) EXECUTORROLE() ([32]byte, error) { + return _RBACTimelock.Contract.EXECUTORROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCallerSession) EXECUTORROLE() ([32]byte, error) { + return _RBACTimelock.Contract.EXECUTORROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCaller) PROPOSERROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "PROPOSER_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) PROPOSERROLE() ([32]byte, error) { + return _RBACTimelock.Contract.PROPOSERROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCallerSession) PROPOSERROLE() ([32]byte, error) { + return _RBACTimelock.Contract.PROPOSERROLE(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCaller) GetBlockedFunctionSelectorAt(opts *bind.CallOpts, index *big.Int) ([4]byte, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "getBlockedFunctionSelectorAt", index) + + if err != nil { + return *new([4]byte), err + } + + out0 := *abi.ConvertType(out[0], new([4]byte)).(*[4]byte) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) GetBlockedFunctionSelectorAt(index *big.Int) ([4]byte, error) { + return _RBACTimelock.Contract.GetBlockedFunctionSelectorAt(&_RBACTimelock.CallOpts, index) +} + +func (_RBACTimelock *RBACTimelockCallerSession) GetBlockedFunctionSelectorAt(index *big.Int) ([4]byte, error) { + return _RBACTimelock.Contract.GetBlockedFunctionSelectorAt(&_RBACTimelock.CallOpts, index) +} + +func (_RBACTimelock *RBACTimelockCaller) GetBlockedFunctionSelectorCount(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "getBlockedFunctionSelectorCount") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) GetBlockedFunctionSelectorCount() (*big.Int, error) { + return _RBACTimelock.Contract.GetBlockedFunctionSelectorCount(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCallerSession) GetBlockedFunctionSelectorCount() (*big.Int, error) { + return _RBACTimelock.Contract.GetBlockedFunctionSelectorCount(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCaller) GetMinDelay(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "getMinDelay") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) GetMinDelay() (*big.Int, error) { + return _RBACTimelock.Contract.GetMinDelay(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCallerSession) GetMinDelay() (*big.Int, error) { + return _RBACTimelock.Contract.GetMinDelay(&_RBACTimelock.CallOpts) +} + +func (_RBACTimelock *RBACTimelockCaller) GetRoleAdmin(opts *bind.CallOpts, role [32]byte) ([32]byte, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "getRoleAdmin", role) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) GetRoleAdmin(role [32]byte) ([32]byte, error) { + return _RBACTimelock.Contract.GetRoleAdmin(&_RBACTimelock.CallOpts, role) +} + +func (_RBACTimelock *RBACTimelockCallerSession) GetRoleAdmin(role [32]byte) ([32]byte, error) { + return _RBACTimelock.Contract.GetRoleAdmin(&_RBACTimelock.CallOpts, role) +} + +func (_RBACTimelock *RBACTimelockCaller) GetRoleMember(opts *bind.CallOpts, role [32]byte, index *big.Int) (common.Address, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "getRoleMember", role, index) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) GetRoleMember(role [32]byte, index *big.Int) (common.Address, error) { + return _RBACTimelock.Contract.GetRoleMember(&_RBACTimelock.CallOpts, role, index) +} + +func (_RBACTimelock *RBACTimelockCallerSession) GetRoleMember(role [32]byte, index *big.Int) (common.Address, error) { + return _RBACTimelock.Contract.GetRoleMember(&_RBACTimelock.CallOpts, role, index) +} + +func (_RBACTimelock *RBACTimelockCaller) GetRoleMemberCount(opts *bind.CallOpts, role [32]byte) (*big.Int, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "getRoleMemberCount", role) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) GetRoleMemberCount(role [32]byte) (*big.Int, error) { + return _RBACTimelock.Contract.GetRoleMemberCount(&_RBACTimelock.CallOpts, role) +} + +func (_RBACTimelock *RBACTimelockCallerSession) GetRoleMemberCount(role [32]byte) (*big.Int, error) { + return _RBACTimelock.Contract.GetRoleMemberCount(&_RBACTimelock.CallOpts, role) +} + +func (_RBACTimelock *RBACTimelockCaller) GetTimestamp(opts *bind.CallOpts, id [32]byte) (*big.Int, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "getTimestamp", id) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) GetTimestamp(id [32]byte) (*big.Int, error) { + return _RBACTimelock.Contract.GetTimestamp(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCallerSession) GetTimestamp(id [32]byte) (*big.Int, error) { + return _RBACTimelock.Contract.GetTimestamp(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCaller) HasRole(opts *bind.CallOpts, role [32]byte, account common.Address) (bool, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "hasRole", role, account) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) HasRole(role [32]byte, account common.Address) (bool, error) { + return _RBACTimelock.Contract.HasRole(&_RBACTimelock.CallOpts, role, account) +} + +func (_RBACTimelock *RBACTimelockCallerSession) HasRole(role [32]byte, account common.Address) (bool, error) { + return _RBACTimelock.Contract.HasRole(&_RBACTimelock.CallOpts, role, account) +} + +func (_RBACTimelock *RBACTimelockCaller) HashOperationBatch(opts *bind.CallOpts, calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte) ([32]byte, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "hashOperationBatch", calls, predecessor, salt) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) HashOperationBatch(calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte) ([32]byte, error) { + return _RBACTimelock.Contract.HashOperationBatch(&_RBACTimelock.CallOpts, calls, predecessor, salt) +} + +func (_RBACTimelock *RBACTimelockCallerSession) HashOperationBatch(calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte) ([32]byte, error) { + return _RBACTimelock.Contract.HashOperationBatch(&_RBACTimelock.CallOpts, calls, predecessor, salt) +} + +func (_RBACTimelock *RBACTimelockCaller) IsOperation(opts *bind.CallOpts, id [32]byte) (bool, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "isOperation", id) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) IsOperation(id [32]byte) (bool, error) { + return _RBACTimelock.Contract.IsOperation(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCallerSession) IsOperation(id [32]byte) (bool, error) { + return _RBACTimelock.Contract.IsOperation(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCaller) IsOperationDone(opts *bind.CallOpts, id [32]byte) (bool, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "isOperationDone", id) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) IsOperationDone(id [32]byte) (bool, error) { + return _RBACTimelock.Contract.IsOperationDone(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCallerSession) IsOperationDone(id [32]byte) (bool, error) { + return _RBACTimelock.Contract.IsOperationDone(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCaller) IsOperationPending(opts *bind.CallOpts, id [32]byte) (bool, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "isOperationPending", id) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) IsOperationPending(id [32]byte) (bool, error) { + return _RBACTimelock.Contract.IsOperationPending(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCallerSession) IsOperationPending(id [32]byte) (bool, error) { + return _RBACTimelock.Contract.IsOperationPending(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCaller) IsOperationReady(opts *bind.CallOpts, id [32]byte) (bool, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "isOperationReady", id) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) IsOperationReady(id [32]byte) (bool, error) { + return _RBACTimelock.Contract.IsOperationReady(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCallerSession) IsOperationReady(id [32]byte) (bool, error) { + return _RBACTimelock.Contract.IsOperationReady(&_RBACTimelock.CallOpts, id) +} + +func (_RBACTimelock *RBACTimelockCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { + var out []interface{} + err := _RBACTimelock.contract.Call(opts, &out, "supportsInterface", interfaceId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +func (_RBACTimelock *RBACTimelockSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _RBACTimelock.Contract.SupportsInterface(&_RBACTimelock.CallOpts, interfaceId) +} + +func (_RBACTimelock *RBACTimelockCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _RBACTimelock.Contract.SupportsInterface(&_RBACTimelock.CallOpts, interfaceId) +} + +func (_RBACTimelock *RBACTimelockTransactor) BlockFunctionSelector(opts *bind.TransactOpts, selector [4]byte) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "blockFunctionSelector", selector) +} + +func (_RBACTimelock *RBACTimelockSession) BlockFunctionSelector(selector [4]byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.BlockFunctionSelector(&_RBACTimelock.TransactOpts, selector) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) BlockFunctionSelector(selector [4]byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.BlockFunctionSelector(&_RBACTimelock.TransactOpts, selector) +} + +func (_RBACTimelock *RBACTimelockTransactor) BypasserExecuteBatch(opts *bind.TransactOpts, calls []RBACTimelockCall) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "bypasserExecuteBatch", calls) +} + +func (_RBACTimelock *RBACTimelockSession) BypasserExecuteBatch(calls []RBACTimelockCall) (*types.Transaction, error) { + return _RBACTimelock.Contract.BypasserExecuteBatch(&_RBACTimelock.TransactOpts, calls) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) BypasserExecuteBatch(calls []RBACTimelockCall) (*types.Transaction, error) { + return _RBACTimelock.Contract.BypasserExecuteBatch(&_RBACTimelock.TransactOpts, calls) +} + +func (_RBACTimelock *RBACTimelockTransactor) Cancel(opts *bind.TransactOpts, id [32]byte) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "cancel", id) +} + +func (_RBACTimelock *RBACTimelockSession) Cancel(id [32]byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.Cancel(&_RBACTimelock.TransactOpts, id) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) Cancel(id [32]byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.Cancel(&_RBACTimelock.TransactOpts, id) +} + +func (_RBACTimelock *RBACTimelockTransactor) ExecuteBatch(opts *bind.TransactOpts, calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "executeBatch", calls, predecessor, salt) +} + +func (_RBACTimelock *RBACTimelockSession) ExecuteBatch(calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.ExecuteBatch(&_RBACTimelock.TransactOpts, calls, predecessor, salt) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) ExecuteBatch(calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.ExecuteBatch(&_RBACTimelock.TransactOpts, calls, predecessor, salt) +} + +func (_RBACTimelock *RBACTimelockTransactor) GrantRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "grantRole", role, account) +} + +func (_RBACTimelock *RBACTimelockSession) GrantRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _RBACTimelock.Contract.GrantRole(&_RBACTimelock.TransactOpts, role, account) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) GrantRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _RBACTimelock.Contract.GrantRole(&_RBACTimelock.TransactOpts, role, account) +} + +func (_RBACTimelock *RBACTimelockTransactor) OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "onERC1155BatchReceived", arg0, arg1, arg2, arg3, arg4) +} + +func (_RBACTimelock *RBACTimelockSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.OnERC1155BatchReceived(&_RBACTimelock.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.OnERC1155BatchReceived(&_RBACTimelock.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +func (_RBACTimelock *RBACTimelockTransactor) OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "onERC1155Received", arg0, arg1, arg2, arg3, arg4) +} + +func (_RBACTimelock *RBACTimelockSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.OnERC1155Received(&_RBACTimelock.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.OnERC1155Received(&_RBACTimelock.TransactOpts, arg0, arg1, arg2, arg3, arg4) +} + +func (_RBACTimelock *RBACTimelockTransactor) OnERC721Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "onERC721Received", arg0, arg1, arg2, arg3) +} + +func (_RBACTimelock *RBACTimelockSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.OnERC721Received(&_RBACTimelock.TransactOpts, arg0, arg1, arg2, arg3) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.OnERC721Received(&_RBACTimelock.TransactOpts, arg0, arg1, arg2, arg3) +} + +func (_RBACTimelock *RBACTimelockTransactor) RenounceRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "renounceRole", role, account) +} + +func (_RBACTimelock *RBACTimelockSession) RenounceRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _RBACTimelock.Contract.RenounceRole(&_RBACTimelock.TransactOpts, role, account) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) RenounceRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _RBACTimelock.Contract.RenounceRole(&_RBACTimelock.TransactOpts, role, account) +} + +func (_RBACTimelock *RBACTimelockTransactor) RevokeRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "revokeRole", role, account) +} + +func (_RBACTimelock *RBACTimelockSession) RevokeRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _RBACTimelock.Contract.RevokeRole(&_RBACTimelock.TransactOpts, role, account) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) RevokeRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _RBACTimelock.Contract.RevokeRole(&_RBACTimelock.TransactOpts, role, account) +} + +func (_RBACTimelock *RBACTimelockTransactor) ScheduleBatch(opts *bind.TransactOpts, calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte, delay *big.Int) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "scheduleBatch", calls, predecessor, salt, delay) +} + +func (_RBACTimelock *RBACTimelockSession) ScheduleBatch(calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte, delay *big.Int) (*types.Transaction, error) { + return _RBACTimelock.Contract.ScheduleBatch(&_RBACTimelock.TransactOpts, calls, predecessor, salt, delay) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) ScheduleBatch(calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte, delay *big.Int) (*types.Transaction, error) { + return _RBACTimelock.Contract.ScheduleBatch(&_RBACTimelock.TransactOpts, calls, predecessor, salt, delay) +} + +func (_RBACTimelock *RBACTimelockTransactor) UnblockFunctionSelector(opts *bind.TransactOpts, selector [4]byte) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "unblockFunctionSelector", selector) +} + +func (_RBACTimelock *RBACTimelockSession) UnblockFunctionSelector(selector [4]byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.UnblockFunctionSelector(&_RBACTimelock.TransactOpts, selector) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) UnblockFunctionSelector(selector [4]byte) (*types.Transaction, error) { + return _RBACTimelock.Contract.UnblockFunctionSelector(&_RBACTimelock.TransactOpts, selector) +} + +func (_RBACTimelock *RBACTimelockTransactor) UpdateDelay(opts *bind.TransactOpts, newDelay *big.Int) (*types.Transaction, error) { + return _RBACTimelock.contract.Transact(opts, "updateDelay", newDelay) +} + +func (_RBACTimelock *RBACTimelockSession) UpdateDelay(newDelay *big.Int) (*types.Transaction, error) { + return _RBACTimelock.Contract.UpdateDelay(&_RBACTimelock.TransactOpts, newDelay) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) UpdateDelay(newDelay *big.Int) (*types.Transaction, error) { + return _RBACTimelock.Contract.UpdateDelay(&_RBACTimelock.TransactOpts, newDelay) +} + +func (_RBACTimelock *RBACTimelockTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) { + return _RBACTimelock.contract.RawTransact(opts, nil) +} + +func (_RBACTimelock *RBACTimelockSession) Receive() (*types.Transaction, error) { + return _RBACTimelock.Contract.Receive(&_RBACTimelock.TransactOpts) +} + +func (_RBACTimelock *RBACTimelockTransactorSession) Receive() (*types.Transaction, error) { + return _RBACTimelock.Contract.Receive(&_RBACTimelock.TransactOpts) +} + +type RBACTimelockBypasserCallExecutedIterator struct { + Event *RBACTimelockBypasserCallExecuted + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockBypasserCallExecutedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockBypasserCallExecuted) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockBypasserCallExecuted) + 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() + } +} + +func (it *RBACTimelockBypasserCallExecutedIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockBypasserCallExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockBypasserCallExecuted struct { + Index *big.Int + Target common.Address + Value *big.Int + Data []byte + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterBypasserCallExecuted(opts *bind.FilterOpts, index []*big.Int) (*RBACTimelockBypasserCallExecutedIterator, error) { + + var indexRule []interface{} + for _, indexItem := range index { + indexRule = append(indexRule, indexItem) + } + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "BypasserCallExecuted", indexRule) + if err != nil { + return nil, err + } + return &RBACTimelockBypasserCallExecutedIterator{contract: _RBACTimelock.contract, event: "BypasserCallExecuted", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchBypasserCallExecuted(opts *bind.WatchOpts, sink chan<- *RBACTimelockBypasserCallExecuted, index []*big.Int) (event.Subscription, error) { + + var indexRule []interface{} + for _, indexItem := range index { + indexRule = append(indexRule, indexItem) + } + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "BypasserCallExecuted", indexRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockBypasserCallExecuted) + if err := _RBACTimelock.contract.UnpackLog(event, "BypasserCallExecuted", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseBypasserCallExecuted(log types.Log) (*RBACTimelockBypasserCallExecuted, error) { + event := new(RBACTimelockBypasserCallExecuted) + if err := _RBACTimelock.contract.UnpackLog(event, "BypasserCallExecuted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type RBACTimelockCallExecutedIterator struct { + Event *RBACTimelockCallExecuted + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockCallExecutedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockCallExecuted) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockCallExecuted) + 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() + } +} + +func (it *RBACTimelockCallExecutedIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockCallExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockCallExecuted struct { + Id [32]byte + Index *big.Int + Target common.Address + Value *big.Int + Data []byte + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterCallExecuted(opts *bind.FilterOpts, id [][32]byte, index []*big.Int) (*RBACTimelockCallExecutedIterator, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + var indexRule []interface{} + for _, indexItem := range index { + indexRule = append(indexRule, indexItem) + } + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "CallExecuted", idRule, indexRule) + if err != nil { + return nil, err + } + return &RBACTimelockCallExecutedIterator{contract: _RBACTimelock.contract, event: "CallExecuted", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchCallExecuted(opts *bind.WatchOpts, sink chan<- *RBACTimelockCallExecuted, id [][32]byte, index []*big.Int) (event.Subscription, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + var indexRule []interface{} + for _, indexItem := range index { + indexRule = append(indexRule, indexItem) + } + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "CallExecuted", idRule, indexRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockCallExecuted) + if err := _RBACTimelock.contract.UnpackLog(event, "CallExecuted", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseCallExecuted(log types.Log) (*RBACTimelockCallExecuted, error) { + event := new(RBACTimelockCallExecuted) + if err := _RBACTimelock.contract.UnpackLog(event, "CallExecuted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type RBACTimelockCallScheduledIterator struct { + Event *RBACTimelockCallScheduled + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockCallScheduledIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockCallScheduled) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockCallScheduled) + 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() + } +} + +func (it *RBACTimelockCallScheduledIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockCallScheduledIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockCallScheduled struct { + Id [32]byte + Index *big.Int + Target common.Address + Value *big.Int + Data []byte + Predecessor [32]byte + Salt [32]byte + Delay *big.Int + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterCallScheduled(opts *bind.FilterOpts, id [][32]byte, index []*big.Int) (*RBACTimelockCallScheduledIterator, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + var indexRule []interface{} + for _, indexItem := range index { + indexRule = append(indexRule, indexItem) + } + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "CallScheduled", idRule, indexRule) + if err != nil { + return nil, err + } + return &RBACTimelockCallScheduledIterator{contract: _RBACTimelock.contract, event: "CallScheduled", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchCallScheduled(opts *bind.WatchOpts, sink chan<- *RBACTimelockCallScheduled, id [][32]byte, index []*big.Int) (event.Subscription, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + var indexRule []interface{} + for _, indexItem := range index { + indexRule = append(indexRule, indexItem) + } + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "CallScheduled", idRule, indexRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockCallScheduled) + if err := _RBACTimelock.contract.UnpackLog(event, "CallScheduled", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseCallScheduled(log types.Log) (*RBACTimelockCallScheduled, error) { + event := new(RBACTimelockCallScheduled) + if err := _RBACTimelock.contract.UnpackLog(event, "CallScheduled", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type RBACTimelockCancelledIterator struct { + Event *RBACTimelockCancelled + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockCancelledIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockCancelled) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockCancelled) + 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() + } +} + +func (it *RBACTimelockCancelledIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockCancelledIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockCancelled struct { + Id [32]byte + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterCancelled(opts *bind.FilterOpts, id [][32]byte) (*RBACTimelockCancelledIterator, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "Cancelled", idRule) + if err != nil { + return nil, err + } + return &RBACTimelockCancelledIterator{contract: _RBACTimelock.contract, event: "Cancelled", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchCancelled(opts *bind.WatchOpts, sink chan<- *RBACTimelockCancelled, id [][32]byte) (event.Subscription, error) { + + var idRule []interface{} + for _, idItem := range id { + idRule = append(idRule, idItem) + } + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "Cancelled", idRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockCancelled) + if err := _RBACTimelock.contract.UnpackLog(event, "Cancelled", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseCancelled(log types.Log) (*RBACTimelockCancelled, error) { + event := new(RBACTimelockCancelled) + if err := _RBACTimelock.contract.UnpackLog(event, "Cancelled", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type RBACTimelockFunctionSelectorBlockedIterator struct { + Event *RBACTimelockFunctionSelectorBlocked + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockFunctionSelectorBlockedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockFunctionSelectorBlocked) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockFunctionSelectorBlocked) + 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() + } +} + +func (it *RBACTimelockFunctionSelectorBlockedIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockFunctionSelectorBlockedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockFunctionSelectorBlocked struct { + Selector [4]byte + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterFunctionSelectorBlocked(opts *bind.FilterOpts, selector [][4]byte) (*RBACTimelockFunctionSelectorBlockedIterator, error) { + + var selectorRule []interface{} + for _, selectorItem := range selector { + selectorRule = append(selectorRule, selectorItem) + } + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "FunctionSelectorBlocked", selectorRule) + if err != nil { + return nil, err + } + return &RBACTimelockFunctionSelectorBlockedIterator{contract: _RBACTimelock.contract, event: "FunctionSelectorBlocked", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchFunctionSelectorBlocked(opts *bind.WatchOpts, sink chan<- *RBACTimelockFunctionSelectorBlocked, selector [][4]byte) (event.Subscription, error) { + + var selectorRule []interface{} + for _, selectorItem := range selector { + selectorRule = append(selectorRule, selectorItem) + } + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "FunctionSelectorBlocked", selectorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockFunctionSelectorBlocked) + if err := _RBACTimelock.contract.UnpackLog(event, "FunctionSelectorBlocked", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseFunctionSelectorBlocked(log types.Log) (*RBACTimelockFunctionSelectorBlocked, error) { + event := new(RBACTimelockFunctionSelectorBlocked) + if err := _RBACTimelock.contract.UnpackLog(event, "FunctionSelectorBlocked", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type RBACTimelockFunctionSelectorUnblockedIterator struct { + Event *RBACTimelockFunctionSelectorUnblocked + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockFunctionSelectorUnblockedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockFunctionSelectorUnblocked) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockFunctionSelectorUnblocked) + 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() + } +} + +func (it *RBACTimelockFunctionSelectorUnblockedIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockFunctionSelectorUnblockedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockFunctionSelectorUnblocked struct { + Selector [4]byte + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterFunctionSelectorUnblocked(opts *bind.FilterOpts, selector [][4]byte) (*RBACTimelockFunctionSelectorUnblockedIterator, error) { + + var selectorRule []interface{} + for _, selectorItem := range selector { + selectorRule = append(selectorRule, selectorItem) + } + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "FunctionSelectorUnblocked", selectorRule) + if err != nil { + return nil, err + } + return &RBACTimelockFunctionSelectorUnblockedIterator{contract: _RBACTimelock.contract, event: "FunctionSelectorUnblocked", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchFunctionSelectorUnblocked(opts *bind.WatchOpts, sink chan<- *RBACTimelockFunctionSelectorUnblocked, selector [][4]byte) (event.Subscription, error) { + + var selectorRule []interface{} + for _, selectorItem := range selector { + selectorRule = append(selectorRule, selectorItem) + } + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "FunctionSelectorUnblocked", selectorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockFunctionSelectorUnblocked) + if err := _RBACTimelock.contract.UnpackLog(event, "FunctionSelectorUnblocked", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseFunctionSelectorUnblocked(log types.Log) (*RBACTimelockFunctionSelectorUnblocked, error) { + event := new(RBACTimelockFunctionSelectorUnblocked) + if err := _RBACTimelock.contract.UnpackLog(event, "FunctionSelectorUnblocked", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type RBACTimelockMinDelayChangeIterator struct { + Event *RBACTimelockMinDelayChange + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockMinDelayChangeIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockMinDelayChange) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockMinDelayChange) + 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() + } +} + +func (it *RBACTimelockMinDelayChangeIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockMinDelayChangeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockMinDelayChange struct { + OldDuration *big.Int + NewDuration *big.Int + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterMinDelayChange(opts *bind.FilterOpts) (*RBACTimelockMinDelayChangeIterator, error) { + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "MinDelayChange") + if err != nil { + return nil, err + } + return &RBACTimelockMinDelayChangeIterator{contract: _RBACTimelock.contract, event: "MinDelayChange", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchMinDelayChange(opts *bind.WatchOpts, sink chan<- *RBACTimelockMinDelayChange) (event.Subscription, error) { + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "MinDelayChange") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockMinDelayChange) + if err := _RBACTimelock.contract.UnpackLog(event, "MinDelayChange", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseMinDelayChange(log types.Log) (*RBACTimelockMinDelayChange, error) { + event := new(RBACTimelockMinDelayChange) + if err := _RBACTimelock.contract.UnpackLog(event, "MinDelayChange", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type RBACTimelockRoleAdminChangedIterator struct { + Event *RBACTimelockRoleAdminChanged + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockRoleAdminChangedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockRoleAdminChanged) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockRoleAdminChanged) + 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() + } +} + +func (it *RBACTimelockRoleAdminChangedIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockRoleAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockRoleAdminChanged struct { + Role [32]byte + PreviousAdminRole [32]byte + NewAdminRole [32]byte + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterRoleAdminChanged(opts *bind.FilterOpts, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (*RBACTimelockRoleAdminChangedIterator, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var previousAdminRoleRule []interface{} + for _, previousAdminRoleItem := range previousAdminRole { + previousAdminRoleRule = append(previousAdminRoleRule, previousAdminRoleItem) + } + var newAdminRoleRule []interface{} + for _, newAdminRoleItem := range newAdminRole { + newAdminRoleRule = append(newAdminRoleRule, newAdminRoleItem) + } + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "RoleAdminChanged", roleRule, previousAdminRoleRule, newAdminRoleRule) + if err != nil { + return nil, err + } + return &RBACTimelockRoleAdminChangedIterator{contract: _RBACTimelock.contract, event: "RoleAdminChanged", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchRoleAdminChanged(opts *bind.WatchOpts, sink chan<- *RBACTimelockRoleAdminChanged, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (event.Subscription, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var previousAdminRoleRule []interface{} + for _, previousAdminRoleItem := range previousAdminRole { + previousAdminRoleRule = append(previousAdminRoleRule, previousAdminRoleItem) + } + var newAdminRoleRule []interface{} + for _, newAdminRoleItem := range newAdminRole { + newAdminRoleRule = append(newAdminRoleRule, newAdminRoleItem) + } + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "RoleAdminChanged", roleRule, previousAdminRoleRule, newAdminRoleRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockRoleAdminChanged) + if err := _RBACTimelock.contract.UnpackLog(event, "RoleAdminChanged", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseRoleAdminChanged(log types.Log) (*RBACTimelockRoleAdminChanged, error) { + event := new(RBACTimelockRoleAdminChanged) + if err := _RBACTimelock.contract.UnpackLog(event, "RoleAdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type RBACTimelockRoleGrantedIterator struct { + Event *RBACTimelockRoleGranted + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockRoleGrantedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockRoleGranted) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockRoleGranted) + 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() + } +} + +func (it *RBACTimelockRoleGrantedIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockRoleGrantedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockRoleGranted struct { + Role [32]byte + Account common.Address + Sender common.Address + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterRoleGranted(opts *bind.FilterOpts, role [][32]byte, account []common.Address, sender []common.Address) (*RBACTimelockRoleGrantedIterator, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "RoleGranted", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return &RBACTimelockRoleGrantedIterator{contract: _RBACTimelock.contract, event: "RoleGranted", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchRoleGranted(opts *bind.WatchOpts, sink chan<- *RBACTimelockRoleGranted, role [][32]byte, account []common.Address, sender []common.Address) (event.Subscription, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "RoleGranted", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockRoleGranted) + if err := _RBACTimelock.contract.UnpackLog(event, "RoleGranted", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseRoleGranted(log types.Log) (*RBACTimelockRoleGranted, error) { + event := new(RBACTimelockRoleGranted) + if err := _RBACTimelock.contract.UnpackLog(event, "RoleGranted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +type RBACTimelockRoleRevokedIterator struct { + Event *RBACTimelockRoleRevoked + + contract *bind.BoundContract + event string + + logs chan types.Log + sub ethereum.Subscription + done bool + fail error +} + +func (it *RBACTimelockRoleRevokedIterator) Next() bool { + + if it.fail != nil { + return false + } + + if it.done { + select { + case log := <-it.logs: + it.Event = new(RBACTimelockRoleRevoked) + 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 + } + } + + select { + case log := <-it.logs: + it.Event = new(RBACTimelockRoleRevoked) + 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() + } +} + +func (it *RBACTimelockRoleRevokedIterator) Error() error { + return it.fail +} + +func (it *RBACTimelockRoleRevokedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +type RBACTimelockRoleRevoked struct { + Role [32]byte + Account common.Address + Sender common.Address + Raw types.Log +} + +func (_RBACTimelock *RBACTimelockFilterer) FilterRoleRevoked(opts *bind.FilterOpts, role [][32]byte, account []common.Address, sender []common.Address) (*RBACTimelockRoleRevokedIterator, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _RBACTimelock.contract.FilterLogs(opts, "RoleRevoked", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return &RBACTimelockRoleRevokedIterator{contract: _RBACTimelock.contract, event: "RoleRevoked", logs: logs, sub: sub}, nil +} + +func (_RBACTimelock *RBACTimelockFilterer) WatchRoleRevoked(opts *bind.WatchOpts, sink chan<- *RBACTimelockRoleRevoked, role [][32]byte, account []common.Address, sender []common.Address) (event.Subscription, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _RBACTimelock.contract.WatchLogs(opts, "RoleRevoked", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + + event := new(RBACTimelockRoleRevoked) + if err := _RBACTimelock.contract.UnpackLog(event, "RoleRevoked", 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 +} + +func (_RBACTimelock *RBACTimelockFilterer) ParseRoleRevoked(log types.Log) (*RBACTimelockRoleRevoked, error) { + event := new(RBACTimelockRoleRevoked) + if err := _RBACTimelock.contract.UnpackLog(event, "RoleRevoked", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +func (_RBACTimelock *RBACTimelock) ParseLog(log types.Log) (AbigenLog, error) { + switch log.Topics[0] { + case _RBACTimelock.abi.Events["BypasserCallExecuted"].ID: + return _RBACTimelock.ParseBypasserCallExecuted(log) + case _RBACTimelock.abi.Events["CallExecuted"].ID: + return _RBACTimelock.ParseCallExecuted(log) + case _RBACTimelock.abi.Events["CallScheduled"].ID: + return _RBACTimelock.ParseCallScheduled(log) + case _RBACTimelock.abi.Events["Cancelled"].ID: + return _RBACTimelock.ParseCancelled(log) + case _RBACTimelock.abi.Events["FunctionSelectorBlocked"].ID: + return _RBACTimelock.ParseFunctionSelectorBlocked(log) + case _RBACTimelock.abi.Events["FunctionSelectorUnblocked"].ID: + return _RBACTimelock.ParseFunctionSelectorUnblocked(log) + case _RBACTimelock.abi.Events["MinDelayChange"].ID: + return _RBACTimelock.ParseMinDelayChange(log) + case _RBACTimelock.abi.Events["RoleAdminChanged"].ID: + return _RBACTimelock.ParseRoleAdminChanged(log) + case _RBACTimelock.abi.Events["RoleGranted"].ID: + return _RBACTimelock.ParseRoleGranted(log) + case _RBACTimelock.abi.Events["RoleRevoked"].ID: + return _RBACTimelock.ParseRoleRevoked(log) + + default: + return nil, fmt.Errorf("abigen wrapper received unknown log topic: %v", log.Topics[0]) + } +} + +func (RBACTimelockBypasserCallExecuted) Topic() common.Hash { + return common.HexToHash("0x6b983f337bab73dfe37faca733adf3ea35b45b8b144ec8ee2de3a1b224564b0c") +} + +func (RBACTimelockCallExecuted) Topic() common.Hash { + return common.HexToHash("0xc2617efa69bab66782fa219543714338489c4e9e178271560a91b82c3f612b58") +} + +func (RBACTimelockCallScheduled) Topic() common.Hash { + return common.HexToHash("0x4f4da6666f52e3b6dbc3638d8eae4017722678fe58bca79cd8320817807a65be") +} + +func (RBACTimelockCancelled) Topic() common.Hash { + return common.HexToHash("0xbaa1eb22f2a492ba1a5fea61b8df4d27c6c8b5f3971e63bb58fa14ff72eedb70") +} + +func (RBACTimelockFunctionSelectorBlocked) Topic() common.Hash { + return common.HexToHash("0x15b40cf8ed4c95cd3c0e1dedfdb3987c3f9bf3d3770d13ddf6dc4daa5ffae9ef") +} + +func (RBACTimelockFunctionSelectorUnblocked) Topic() common.Hash { + return common.HexToHash("0xd91859a8d88193a56a2983deb65a5253985141c49c70bf016880b5243bd432e1") +} + +func (RBACTimelockMinDelayChange) Topic() common.Hash { + return common.HexToHash("0x11c24f4ead16507c69ac467fbd5e4eed5fb5c699626d2cc6d66421df253886d5") +} + +func (RBACTimelockRoleAdminChanged) Topic() common.Hash { + return common.HexToHash("0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff") +} + +func (RBACTimelockRoleGranted) Topic() common.Hash { + return common.HexToHash("0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d") +} + +func (RBACTimelockRoleRevoked) Topic() common.Hash { + return common.HexToHash("0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b") +} + +func (_RBACTimelock *RBACTimelock) Address() common.Address { + return _RBACTimelock.address +} + +type RBACTimelockInterface interface { + ADMINROLE(opts *bind.CallOpts) ([32]byte, error) + + BYPASSERROLE(opts *bind.CallOpts) ([32]byte, error) + + CANCELLERROLE(opts *bind.CallOpts) ([32]byte, error) + + DEFAULTADMINROLE(opts *bind.CallOpts) ([32]byte, error) + + EXECUTORROLE(opts *bind.CallOpts) ([32]byte, error) + + PROPOSERROLE(opts *bind.CallOpts) ([32]byte, error) + + GetBlockedFunctionSelectorAt(opts *bind.CallOpts, index *big.Int) ([4]byte, error) + + GetBlockedFunctionSelectorCount(opts *bind.CallOpts) (*big.Int, error) + + GetMinDelay(opts *bind.CallOpts) (*big.Int, error) + + GetRoleAdmin(opts *bind.CallOpts, role [32]byte) ([32]byte, error) + + GetRoleMember(opts *bind.CallOpts, role [32]byte, index *big.Int) (common.Address, error) + + GetRoleMemberCount(opts *bind.CallOpts, role [32]byte) (*big.Int, error) + + GetTimestamp(opts *bind.CallOpts, id [32]byte) (*big.Int, error) + + HasRole(opts *bind.CallOpts, role [32]byte, account common.Address) (bool, error) + + HashOperationBatch(opts *bind.CallOpts, calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte) ([32]byte, error) + + IsOperation(opts *bind.CallOpts, id [32]byte) (bool, error) + + IsOperationDone(opts *bind.CallOpts, id [32]byte) (bool, error) + + IsOperationPending(opts *bind.CallOpts, id [32]byte) (bool, error) + + IsOperationReady(opts *bind.CallOpts, id [32]byte) (bool, error) + + SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) + + BlockFunctionSelector(opts *bind.TransactOpts, selector [4]byte) (*types.Transaction, error) + + BypasserExecuteBatch(opts *bind.TransactOpts, calls []RBACTimelockCall) (*types.Transaction, error) + + Cancel(opts *bind.TransactOpts, id [32]byte) (*types.Transaction, error) + + ExecuteBatch(opts *bind.TransactOpts, calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte) (*types.Transaction, error) + + GrantRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) + + OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, arg4 []byte) (*types.Transaction, error) + + OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) + + OnERC721Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error) + + RenounceRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) + + RevokeRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) + + ScheduleBatch(opts *bind.TransactOpts, calls []RBACTimelockCall, predecessor [32]byte, salt [32]byte, delay *big.Int) (*types.Transaction, error) + + UnblockFunctionSelector(opts *bind.TransactOpts, selector [4]byte) (*types.Transaction, error) + + UpdateDelay(opts *bind.TransactOpts, newDelay *big.Int) (*types.Transaction, error) + + Receive(opts *bind.TransactOpts) (*types.Transaction, error) + + FilterBypasserCallExecuted(opts *bind.FilterOpts, index []*big.Int) (*RBACTimelockBypasserCallExecutedIterator, error) + + WatchBypasserCallExecuted(opts *bind.WatchOpts, sink chan<- *RBACTimelockBypasserCallExecuted, index []*big.Int) (event.Subscription, error) + + ParseBypasserCallExecuted(log types.Log) (*RBACTimelockBypasserCallExecuted, error) + + FilterCallExecuted(opts *bind.FilterOpts, id [][32]byte, index []*big.Int) (*RBACTimelockCallExecutedIterator, error) + + WatchCallExecuted(opts *bind.WatchOpts, sink chan<- *RBACTimelockCallExecuted, id [][32]byte, index []*big.Int) (event.Subscription, error) + + ParseCallExecuted(log types.Log) (*RBACTimelockCallExecuted, error) + + FilterCallScheduled(opts *bind.FilterOpts, id [][32]byte, index []*big.Int) (*RBACTimelockCallScheduledIterator, error) + + WatchCallScheduled(opts *bind.WatchOpts, sink chan<- *RBACTimelockCallScheduled, id [][32]byte, index []*big.Int) (event.Subscription, error) + + ParseCallScheduled(log types.Log) (*RBACTimelockCallScheduled, error) + + FilterCancelled(opts *bind.FilterOpts, id [][32]byte) (*RBACTimelockCancelledIterator, error) + + WatchCancelled(opts *bind.WatchOpts, sink chan<- *RBACTimelockCancelled, id [][32]byte) (event.Subscription, error) + + ParseCancelled(log types.Log) (*RBACTimelockCancelled, error) + + FilterFunctionSelectorBlocked(opts *bind.FilterOpts, selector [][4]byte) (*RBACTimelockFunctionSelectorBlockedIterator, error) + + WatchFunctionSelectorBlocked(opts *bind.WatchOpts, sink chan<- *RBACTimelockFunctionSelectorBlocked, selector [][4]byte) (event.Subscription, error) + + ParseFunctionSelectorBlocked(log types.Log) (*RBACTimelockFunctionSelectorBlocked, error) + + FilterFunctionSelectorUnblocked(opts *bind.FilterOpts, selector [][4]byte) (*RBACTimelockFunctionSelectorUnblockedIterator, error) + + WatchFunctionSelectorUnblocked(opts *bind.WatchOpts, sink chan<- *RBACTimelockFunctionSelectorUnblocked, selector [][4]byte) (event.Subscription, error) + + ParseFunctionSelectorUnblocked(log types.Log) (*RBACTimelockFunctionSelectorUnblocked, error) + + FilterMinDelayChange(opts *bind.FilterOpts) (*RBACTimelockMinDelayChangeIterator, error) + + WatchMinDelayChange(opts *bind.WatchOpts, sink chan<- *RBACTimelockMinDelayChange) (event.Subscription, error) + + ParseMinDelayChange(log types.Log) (*RBACTimelockMinDelayChange, error) + + FilterRoleAdminChanged(opts *bind.FilterOpts, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (*RBACTimelockRoleAdminChangedIterator, error) + + WatchRoleAdminChanged(opts *bind.WatchOpts, sink chan<- *RBACTimelockRoleAdminChanged, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (event.Subscription, error) + + ParseRoleAdminChanged(log types.Log) (*RBACTimelockRoleAdminChanged, error) + + FilterRoleGranted(opts *bind.FilterOpts, role [][32]byte, account []common.Address, sender []common.Address) (*RBACTimelockRoleGrantedIterator, error) + + WatchRoleGranted(opts *bind.WatchOpts, sink chan<- *RBACTimelockRoleGranted, role [][32]byte, account []common.Address, sender []common.Address) (event.Subscription, error) + + ParseRoleGranted(log types.Log) (*RBACTimelockRoleGranted, error) + + FilterRoleRevoked(opts *bind.FilterOpts, role [][32]byte, account []common.Address, sender []common.Address) (*RBACTimelockRoleRevokedIterator, error) + + WatchRoleRevoked(opts *bind.WatchOpts, sink chan<- *RBACTimelockRoleRevoked, role [][32]byte, account []common.Address, sender []common.Address) (event.Subscription, error) + + ParseRoleRevoked(log types.Log) (*RBACTimelockRoleRevoked, error) + + ParseLog(log types.Log) (AbigenLog, error) + + Address() common.Address +} From 87b936333d8c2836711ee4655280838c86e9acac Mon Sep 17 00:00:00 2001 From: Ryan <80392855+RayXpub@users.noreply.github.com> Date: Wed, 22 Apr 2026 19:20:20 +0200 Subject: [PATCH 2/2] chore: rename ReadABIAndByteCode and evmFunctionConfig --- tools/operations-gen/internal/families/evm/abi.go | 4 ++-- tools/operations-gen/internal/families/evm/abi_test.go | 2 +- tools/operations-gen/internal/families/evm/config.go | 6 +++--- tools/operations-gen/internal/families/evm/contract.go | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/tools/operations-gen/internal/families/evm/abi.go b/tools/operations-gen/internal/families/evm/abi.go index 17ec9c20d..5a1e2d21e 100644 --- a/tools/operations-gen/internal/families/evm/abi.go +++ b/tools/operations-gen/internal/families/evm/abi.go @@ -62,12 +62,12 @@ type ABIParam struct { Components []ABIParam `json:"components"` } -// ReadABIAndByteCode reads the ABI JSON and (optionally) bytecode for a contract +// ReadABIAndBytecode reads the ABI JSON and (optionally) bytecode for a contract // from the configured input roots: // // {input.ABIBasePath}/{versionPath}/{name}.json // {input.BytecodeBasePath}/{versionPath}/{name}.bin -func ReadABIAndByteCode( +func ReadABIAndBytecode( cfg EvmContractConfig, packageName, versionPath string, diff --git a/tools/operations-gen/internal/families/evm/abi_test.go b/tools/operations-gen/internal/families/evm/abi_test.go index f916ed384..852cec59d 100644 --- a/tools/operations-gen/internal/families/evm/abi_test.go +++ b/tools/operations-gen/internal/families/evm/abi_test.go @@ -163,7 +163,7 @@ func TestFindFunctionInABIOverloads(t *testing.T) { func TestReadABIAndBytecodeInvalidABIFileSuffix(t *testing.T) { t.Parallel() cfg := evm.EvmContractConfig{ABIFile: "contract.abi"} - _, _, err := evm.ReadABIAndByteCode(cfg, "contract", "v1_0_0", evm.EvmInputConfig{ + _, _, err := evm.ReadABIAndBytecode(cfg, "contract", "v1_0_0", evm.EvmInputConfig{ ABIBasePath: t.TempDir(), BytecodeBasePath: t.TempDir(), }) diff --git a/tools/operations-gen/internal/families/evm/config.go b/tools/operations-gen/internal/families/evm/config.go index 47cd88e07..8e519aad2 100644 --- a/tools/operations-gen/internal/families/evm/config.go +++ b/tools/operations-gen/internal/families/evm/config.go @@ -8,11 +8,11 @@ type EvmContractConfig struct { PackageName string `yaml:"package_name,omitempty"` // Optional: override package name ABIFile string `yaml:"abi_file,omitempty"` // Optional: override ABI file name OmitDeploy bool `yaml:"omit_deploy,omitempty"` // Optional: skip Deploy operation - Functions []evmFunctionConfig `yaml:"functions"` + Functions []EvmFunctionConfig `yaml:"functions"` } -// evmFunctionConfig selects a contract function and assigns its access control. -type evmFunctionConfig struct { +// EvmFunctionConfig selects a contract function and assigns its access control. +type EvmFunctionConfig struct { Name string `yaml:"name"` Access string `yaml:"access,omitempty"` // "owner" or "public" } diff --git a/tools/operations-gen/internal/families/evm/contract.go b/tools/operations-gen/internal/families/evm/contract.go index 9506e50de..46a22b248 100644 --- a/tools/operations-gen/internal/families/evm/contract.go +++ b/tools/operations-gen/internal/families/evm/contract.go @@ -70,7 +70,7 @@ func extractContractInfo(cfg EvmContractConfig, input EvmInputConfig, output Evm return nil, err } - abiString, bytecode, err := ReadABIAndByteCode(cfg, packageName, versionPath, input) + abiString, bytecode, err := ReadABIAndBytecode(cfg, packageName, versionPath, input) if err != nil { return nil, err } @@ -112,7 +112,7 @@ func extractConstructor(info *ContractInfo, abiEntries []ABIEntry, typeMap map[s } } -func extractFunctions(info *ContractInfo, funcConfigs []evmFunctionConfig, abiEntries []ABIEntry, typeMap map[string]string) error { +func extractFunctions(info *ContractInfo, funcConfigs []EvmFunctionConfig, abiEntries []ABIEntry, typeMap map[string]string) error { for _, funcCfg := range funcConfigs { funcInfos := FindFunctionInABI(abiEntries, funcCfg.Name, info.PackageName, typeMap) if funcInfos == nil {